func (suite *LibTestSuite) TestCompositeTypes() {
// [false true]
suite.EqualValues(
types.NewList().Append(types.Bool(false)).Append(types.Bool(true)),
util.NomsValueFromDecodedJSON([]interface{}{false, true}, false))
// [[false true]]
suite.EqualValues(
types.NewList().Append(
types.NewList().Append(types.Bool(false)).Append(types.Bool(true))),
util.NomsValueFromDecodedJSON([]interface{}{[]interface{}{false, true}}, false))
// {"string": "string",
// "list": [false true],
// "map": {"nested": "string"}
// }
m := types.NewMap(
types.String("string"),
types.String("string"),
types.String("list"),
types.NewList().Append(types.Bool(false)).Append(types.Bool(true)),
types.String("map"),
types.NewMap(
types.String("nested"),
types.String("string")))
o := util.NomsValueFromDecodedJSON(map[string]interface{}{
"string": "string",
"list": []interface{}{false, true},
"map": map[string]interface{}{"nested": "string"},
}, false)
suite.True(m.Equals(o))
}
func (suite *LibTestSuite) TestCompositeTypeWithStruct() {
// {"string": "string",
// "list": [false true],
// "struct": {"nested": "string"}
// }
tstruct := types.NewStruct("", map[string]types.Value{
"string": types.String("string"),
"list": types.NewList().Append(types.Bool(false)).Append(types.Bool(true)),
"struct": types.NewStruct("", map[string]types.Value{
"nested": types.String("string"),
}),
})
o := util.NomsValueFromDecodedJSON(map[string]interface{}{
"string": "string",
"list": []interface{}{false, true},
"struct": map[string]interface{}{"nested": "string"},
}, true)
suite.True(tstruct.Equals(o))
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "usage: %s <url> <dataset>\n", os.Args[0])
flag.PrintDefaults()
}
spec.RegisterDatabaseFlags()
flag.Parse()
if len(flag.Args()) != 2 {
util.CheckError(errors.New("expected url and dataset flags"))
}
ds, err := spec.GetDataset(flag.Arg(1))
util.CheckError(err)
url := flag.Arg(0)
if url == "" {
flag.Usage()
}
res, err := http.Get(url)
if err != nil {
log.Fatalf("Error fetching %s: %+v\n", url, err)
} else if res.StatusCode != 200 {
log.Fatalf("Error fetching %s: %s\n", url, res.Status)
}
defer res.Body.Close()
var jsonObject interface{}
err = json.NewDecoder(res.Body).Decode(&jsonObject)
if err != nil {
log.Fatalln("Error decoding JSON: ", err)
}
_, err = ds.Commit(util.NomsValueFromDecodedJSON(jsonObject, true))
d.Exp.NoError(err)
ds.Database().Close()
}
func main() {
err := d.Try(func() {
spec.RegisterDatabaseFlags()
flag.Usage = customUsage
flag.Parse()
if flag.NArg() != 2 {
util.CheckError(errors.New("Expected dataset followed by directory path"))
}
dir := flag.Arg(1)
ds, err := spec.GetDataset(flag.Arg(0))
util.CheckError(err)
defer profile.MaybeStartProfile().Stop()
cpuCount := runtime.NumCPU()
runtime.GOMAXPROCS(cpuCount)
filesChan := make(chan fileIndex, 1024)
refsChan := make(chan refIndex, 1024)
getFilePaths := func() {
index := 0
err := filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
d.Exp.NoError(err, "Cannot traverse directories")
if !info.IsDir() && filepath.Ext(path) == ".xml" {
filesChan <- fileIndex{path, index}
index++
}
return nil
})
d.Exp.NoError(err)
close(filesChan)
}
wg := sync.WaitGroup{}
importXML := func() {
expectedType := types.NewMap()
for f := range filesChan {
file, err := os.Open(f.path)
d.Exp.NoError(err, "Error getting XML")
xmlObject, err := mxj.NewMapXmlReader(file)
d.Exp.NoError(err, "Error decoding XML")
object := xmlObject.Old()
file.Close()
nomsObj := util.NomsValueFromDecodedJSON(object, false)
d.Chk.IsType(expectedType, nomsObj)
var r types.Ref
if !*noIO {
r = ds.Database().WriteValue(nomsObj)
}
refsChan <- refIndex{r, f.index}
}
wg.Done()
}
go getFilePaths()
for i := 0; i < cpuCount*8; i++ {
wg.Add(1)
go importXML()
}
go func() {
wg.Wait()
close(refsChan) // done converting xml to noms
}()
refList := refIndexList{}
for r := range refsChan {
refList = append(refList, r)
}
sort.Sort(refList)
refs := make([]types.Value, len(refList))
for idx, r := range refList {
refs[idx] = r.ref
}
rl := types.NewList(refs...)
if !*noIO {
_, err := ds.Commit(rl)
d.Exp.NoError(err)
}
})
if err != nil {
log.Fatal(err)
}
}
func (suite *LibTestSuite) TestPanicOnUnsupportedType() {
suite.Panics(func() { util.NomsValueFromDecodedJSON(map[int]string{1: "one"}, false) }, "Should panic on map[int]string!")
}
func (suite *LibTestSuite) TestPrimitiveTypes() {
suite.EqualValues(types.String("expected"), util.NomsValueFromDecodedJSON("expected", false))
suite.EqualValues(types.Bool(false), util.NomsValueFromDecodedJSON(false, false))
suite.EqualValues(types.Number(1.7), util.NomsValueFromDecodedJSON(1.7, false))
suite.False(util.NomsValueFromDecodedJSON(1.7, false).Equals(types.Bool(true)))
}