func TestPollAndExecOnceError(t *testing.T) {
task := pendingRecreateWebpageArchivesTask()
mockServer := frontend.MockServer{}
mockServer.SetCurrentTask(&task.RecreateWebpageArchivesDBTask)
defer frontend.CloseTestServer(frontend.InitTestServer(&mockServer))
commandCollector := exec.CommandCollector{}
mockRun := exec.MockRun{}
commandCollector.SetDelegateRun(mockRun.Run)
exec.SetRunForTesting(commandCollector.Run)
defer exec.SetRunForTesting(exec.DefaultRun)
mockRun.AddRule("capture_archives_on_workers", fmt.Errorf("workers too lazy"))
pollAndExecOnce()
// Expect only one poll.
expect.Equal(t, 1, mockServer.OldestPendingTaskReqCount())
// Expect three commands: git pull; make all; capture_archives_on_workers ...
commands := commandCollector.Commands()
assert.Len(t, commands, 3)
expect.Equal(t, "git pull", exec.DebugString(commands[0]))
expect.Equal(t, "make all", exec.DebugString(commands[1]))
expect.Equal(t, "capture_archives_on_workers", commands[2].Name)
// Expect an update marking task failed when command fails to execute.
assert.Len(t, mockServer.UpdateTaskReqs(), 1)
updateReq := mockServer.UpdateTaskReqs()[0]
assert.Equal(t, "/"+ctfeutil.UPDATE_RECREATE_WEBPAGE_ARCHIVES_TASK_POST_URI, updateReq.Url)
assert.NoError(t, updateReq.Error)
assert.False(t, updateReq.Vars.TsStarted.Valid)
assert.True(t, updateReq.Vars.TsCompleted.Valid)
assert.True(t, updateReq.Vars.Failure.Valid)
assert.True(t, updateReq.Vars.Failure.Bool)
assert.False(t, updateReq.Vars.RepeatAfterDays.Valid)
assert.Equal(t, int64(42), updateReq.Vars.Id)
}
func TestDetectImagesContainerStopped(t *testing.T) {
manager, fakeRuntime, _ := newRealImageManager(ImageGCPolicy{})
fakeRuntime.ImageList = []container.Image{
makeImage(0, 1024),
makeImage(1, 2048),
}
fakeRuntime.AllPodList = []*container.Pod{
{
Containers: []*container.Container{
makeContainer(1),
},
},
}
err := manager.detectImages(zero)
assert := assert.New(t)
require.NoError(t, err)
assert.Equal(manager.imageRecordsLen(), 2)
withContainer, ok := manager.getImageRecord(imageName(1))
require.True(t, ok)
// Simulate container being stopped.
fakeRuntime.AllPodList = []*container.Pod{}
err = manager.detectImages(time.Now())
require.NoError(t, err)
assert.Equal(manager.imageRecordsLen(), 2)
container1, ok := manager.getImageRecord(imageName(0))
require.True(t, ok)
assert.Equal(zero, container1.firstDetected)
assert.Equal(zero, container1.lastUsed)
container2, ok := manager.getImageRecord(imageName(1))
require.True(t, ok)
assert.Equal(zero, container2.firstDetected)
assert.True(container2.lastUsed.Equal(withContainer.lastUsed))
}
func testRasterizer(t *testing.T, rasterizer Rasterizer, expectation string) {
assert.True(t, rasterizer.Enabled(), "%s.Enabled() failed.", rasterizer.String())
testDataDir, err := testutils.TestDataDir()
assert.Nil(t, err, "TestDataDir missing: %v", err)
tempDir, err := ioutil.TempDir("", "pdf_test_")
assert.Nil(t, err, "ioutil.TempDir failed")
defer util.RemoveAll(tempDir)
pdfSrcPath := path.Join(testDataDir, "minimal.pdf")
assert.True(t, fileutil.FileExists(pdfSrcPath), "Path '%s' does not exist", pdfSrcPath)
pdfInputPath := path.Join(tempDir, "minimal.pdf")
err = os.Symlink(pdfSrcPath, pdfInputPath)
assert.Nil(t, err, "Symlink failed")
assert.True(t, fileutil.FileExists(pdfInputPath), "Path '%s' does not exist", pdfInputPath)
outputFileName := path.Join(tempDir, "test.png")
badPath := path.Join(tempDir, "this_file_should_really_not_exist.pdf")
if err := rasterizer.Rasterize(badPath, outputFileName); err == nil {
t.Errorf(": Got '%v' Want '%v'", err, nil)
}
if err := rasterizer.Rasterize(pdfInputPath, outputFileName); err != nil {
t.Errorf(": Got '%v' Want '!nil'", err)
}
expectedOutput := path.Join(testDataDir, expectation)
assert.True(t, filesEqual(outputFileName, expectedOutput), "png output not correct")
}
// This adds a single byte of whitespace to the metadata file, so it should be parsed
// and deserialized the same way, but checksums against snapshot/timestamp may fail
func TestSwizzlerAddExtraSpace(t *testing.T) {
f, origMeta := createNewSwizzler(t)
f.AddExtraSpace(data.CanonicalTargetsRole)
snapshot := &data.SignedSnapshot{}
require.NoError(t, json.Unmarshal(origMeta[data.CanonicalSnapshotRole], snapshot))
for role, metaBytes := range origMeta {
newMeta, err := f.MetadataCache.GetMeta(role, -1)
require.NoError(t, err)
if role != data.CanonicalTargetsRole {
require.True(t, bytes.Equal(metaBytes, newMeta), "bytes have changed for role %s", role)
} else {
require.False(t, bytes.Equal(metaBytes, newMeta))
require.True(t, bytes.Equal(metaBytes, newMeta[1:len(metaBytes)+1]))
require.Equal(t, byte(' '), newMeta[0])
require.Equal(t, byte(' '), newMeta[len(newMeta)-1])
// make sure the hash is not the same as the hash in snapshot
newHash := sha256.Sum256(newMeta)
require.False(t, bytes.Equal(
snapshot.Signed.Meta[data.CanonicalTargetsRole].Hashes["sha256"],
newHash[:]))
require.NotEqual(t,
snapshot.Signed.Meta[data.CanonicalTargetsRole].Length,
len(newMeta))
}
}
}
func TestTransfer(t *testing.T) {
const (
cidr = "10.0.1.7/22"
)
allocs, router, subnet := makeNetworkOfAllocators(3, cidr)
alloc1 := allocs[0]
alloc2 := allocs[1]
alloc3 := allocs[2] // This will be 'master' and get the first range
_, err := alloc2.Allocate("foo", subnet, nil)
require.True(t, err == nil, "Failed to get address")
_, err = alloc3.Allocate("bar", subnet, nil)
require.True(t, err == nil, "Failed to get address")
router.GossipBroadcast(alloc2.Gossip())
router.Flush()
router.GossipBroadcast(alloc3.Gossip())
router.Flush()
router.RemovePeer(alloc2.ourName)
router.RemovePeer(alloc3.ourName)
alloc2.Stop()
alloc3.Stop()
router.Flush()
require.NoError(t, alloc1.AdminTakeoverRanges(alloc2.ourName.String()))
require.NoError(t, alloc1.AdminTakeoverRanges(alloc3.ourName.String()))
router.Flush()
require.Equal(t, address.Offset(1022), alloc1.NumFreeAddresses(subnet))
_, err = alloc1.Allocate("foo", subnet, nil)
require.True(t, err == nil, "Failed to get address")
alloc1.Stop()
}
func TestSpecOptionalOption3Choice(t *testing.T) {
var f, g, h *bool
init := func(c *Cmd) {
f = c.BoolOpt("f", false, "")
g = c.BoolOpt("g", false, "")
h = c.BoolOpt("x", false, "")
}
spec := "[-f|-g|-x]"
okCmd(t, spec, init, []string{})
require.False(t, *f)
require.False(t, *g)
require.False(t, *h)
okCmd(t, spec, init, []string{"-f"})
require.True(t, *f)
require.False(t, *g)
require.False(t, *h)
okCmd(t, spec, init, []string{"-g"})
require.False(t, *f)
require.True(t, *g)
require.False(t, *h)
okCmd(t, spec, init, []string{"-x"})
require.False(t, *f)
require.False(t, *g)
require.True(t, *h)
}
func TestSpecSingleDash(t *testing.T) {
var path *string
var f *bool
init := func(c *Cmd) {
path = c.StringArg("PATH", "", "'-' can be used to read from stdin' ")
f = c.BoolOpt("f", false, "")
}
spec := "[-f] PATH"
okCmd(t, spec, init, []string{"TEST"})
require.Equal(t, "TEST", *path)
require.False(t, *f)
okCmd(t, spec, init, []string{"-f", "TEST"})
require.Equal(t, "TEST", *path)
require.True(t, *f)
okCmd(t, spec, init, []string{"-"})
require.Equal(t, "-", *path)
require.False(t, *f)
okCmd(t, spec, init, []string{"-f", "-"})
require.Equal(t, "-", *path)
require.True(t, *f)
okCmd(t, spec, init, []string{"--", "-"})
require.Equal(t, "-", *path)
require.False(t, *f)
okCmd(t, spec, init, []string{"-f", "--", "-"})
require.Equal(t, "-", *path)
require.True(t, *f)
}
func TestDataKey(t *testing.T) {
var uid uint64
for uid = 0; uid < 1001; uid++ {
sattr := fmt.Sprintf("attr:%d", uid)
key := DataKey(sattr, uid)
pk := Parse(key)
require.True(t, pk.IsData())
require.Equal(t, sattr, pk.Attr)
require.Equal(t, uid, pk.Uid)
}
keys := make([]string, 0, 1024)
for uid = 1024; uid >= 1; uid-- {
key := DataKey("testing.key", uid)
keys = append(keys, string(key))
}
// Test that sorting is as expected.
sort.Strings(keys)
require.True(t, sort.StringsAreSorted(keys))
for i, key := range keys {
exp := DataKey("testing.key", uint64(i+1))
require.Equal(t, string(exp), key)
}
}
func TestSpaceFree(t *testing.T) {
const (
testAddr1 = "10.0.3.16"
testAddrx = "10.0.3.19"
testAddry = "10.0.9.19"
containerID = "deadbeef"
size = 16
)
entireRange := address.NewRange(ip(testAddr1), size)
space := makeSpace(ip(testAddr1), size)
// Check we are prepared to give up the entire space
r := space.biggestFreeRange(entireRange)
require.Equal(t, address.NewRange(ip(testAddr1), size), r, "Wrong space")
for i := 0; i < size; i++ {
ok, _ := space.Allocate(entireRange)
require.True(t, ok, "Failed to get address")
}
// Check we are full
ok, _ := space.Allocate(entireRange)
require.True(t, !ok, "Should have failed to get address")
r, _ = space.Donate(entireRange)
require.True(t, r.Size() == 0, "Wrong space")
// Free in the middle
require.NoError(t, space.Free(ip("10.0.3.23")))
r = space.biggestFreeRange(entireRange)
require.True(t, r.Start == ip("10.0.3.23") && r.Size() == 1, "Wrong space")
// Free one at the end
require.NoError(t, space.Free(ip("10.0.3.31")))
r = space.biggestFreeRange(entireRange)
require.True(t, r.Start == ip("10.0.3.31") && r.Size() == 1, "Wrong space")
// Now free a few at the end
require.NoError(t, space.Free(ip("10.0.3.30")))
require.NoError(t, space.Free(ip("10.0.3.29")))
require.Equal(t, address.Count(4), space.NumFreeAddresses())
// Now get the biggest free space; should be 3.30
r = space.biggestFreeRange(entireRange)
require.Equal(t, address.NewRange(ip("10.0.3.30"), 2), r, "Wrong space")
// Now free a few in the middle
require.NoError(t, space.Free(ip("10.0.3.24")))
require.NoError(t, space.Free(ip("10.0.3.22")))
require.NoError(t, space.Free(ip("10.0.3.21")))
require.Equal(t, address.Count(7), space.NumFreeAddresses())
// Now get the biggest free space; should be 3.30
r = space.biggestFreeRange(entireRange)
require.Equal(t, address.NewRange(ip("10.0.3.30"), 2), r, "Wrong space")
require.Equal(t, []address.Range{{Start: ip("10.0.3.16"), End: ip("10.0.3.32")}}, space.OwnedRanges())
}
func TestMatchesFilterIntersectsPoint(t *testing.T) {
p := geom.NewPoint(geom.XY).MustSetCoords(geom.Coord{-122.082506, 37.4249518})
data := formDataPoint(t, p)
_, qd, err := queryTokens(QueryTypeIntersects, data, 0.0)
require.NoError(t, err)
// Same point
p2 := geom.NewPoint(geom.XY).MustSetCoords(geom.Coord{-122.082506, 37.4249518})
require.True(t, qd.MatchesFilter(types.Geo{p2}))
// Different point
p3 := geom.NewPoint(geom.XY).MustSetCoords(geom.Coord{-123.082506, 37.4249518})
require.False(t, qd.MatchesFilter(types.Geo{p3}))
// containing poly
poly := geom.NewPolygon(geom.XY).MustSetCoords([][]geom.Coord{
{{-122, 37}, {-123, 37}, {-123, 38}, {-122, 38}, {-122, 37}},
})
require.True(t, qd.MatchesFilter(types.Geo{poly}))
// Polygon doesn't contains
poly = geom.NewPolygon(geom.XY).MustSetCoords([][]geom.Coord{
{{-122, 36}, {-123, 36}, {-123, 37}, {-122, 37}, {-122, 36}},
})
require.False(t, qd.MatchesFilter(types.Geo{poly}))
}
func TestMergeErrors(t *testing.T) {
// Cannot Merge in an invalid ring
ring1 := New(start, end, peer1name)
ring2 := New(start, end, peer2name)
ring2.Entries = []*entry{{Token: middle, Peer: peer2name}, {Token: start, Peer: peer2name}}
require.True(t, ring1.Merge(*ring2) == ErrNotSorted, "Expected ErrNotSorted")
// Should Merge two rings for different ranges
ring2 = New(start, middle, peer2name)
ring2.Entries = []*entry{}
require.True(t, ring1.Merge(*ring2) == ErrDifferentSubnets, "Expected ErrDifferentSubnets")
// Cannot Merge newer version of entry I own
ring2 = New(start, end, peer2name)
ring1.Entries = []*entry{{Token: start, Peer: peer1name}}
ring2.Entries = []*entry{{Token: start, Peer: peer1name, Version: 1}}
require.True(t, ring1.Merge(*ring2) == ErrNewerVersion, "Expected ErrNewerVersion")
// Cannot Merge two entries with same version but different hosts
ring1.Entries = []*entry{{Token: start, Peer: peer1name}}
ring2.Entries = []*entry{{Token: start, Peer: peer2name}}
require.True(t, ring1.Merge(*ring2) == ErrInvalidEntry, "Expected ErrInvalidEntry")
// Cannot Merge an entry into a range I own
ring1.Entries = []*entry{{Token: start, Peer: peer1name}}
ring2.Entries = []*entry{{Token: middle, Peer: peer2name}}
require.True(t, ring1.Merge(*ring2) == ErrEntryInMyRange, "Expected ErrEntryInMyRange")
}
func TestCryDifferentLocations(t *testing.T) {
require.True(t, CryHeard())
require.True(t, CryHeard())
require.True(t, CryHeard())
require.True(t, CryHeard())
require.True(t, CryHeard())
}
func TestByteConversion(t *testing.T) {
numbers32 := []uint32{5251, uint32Max, 0, 1, 101, 2387, 219}
for _, i := range numbers32 {
data, err := uint32ToBytes(i)
require.NoError(t, err)
require.Len(t, data, 4)
ii, err := bytesToUint32(data)
require.NoError(t, err)
require.True(t, ii == i)
}
numbers16 := []uint16{5251, uint16Max, 0, 1, 101, 2387, 219}
for _, i := range numbers16 {
data, err := uint16ToBytes(i)
require.NoError(t, err)
require.Len(t, data, 2)
ii, err := bytesToUint16(data)
require.NoError(t, err)
require.True(t, ii == i)
}
}
func TestSetupBuildProperties(t *testing.T) {
DownloadCoresAndToolsAndLibraries(t)
ctx := &types.Context{
HardwareFolders: []string{filepath.Join("..", "hardware"), "hardware", "downloaded_hardware", "user_hardware"},
ToolsFolders: []string{"downloaded_tools", "./tools_builtin"},
SketchLocation: filepath.Join("sketch1", "sketch.ino"),
FQBN: "arduino:avr:uno",
ArduinoAPIVersion: "10600",
}
buildPath := SetupBuildPath(t, ctx)
defer os.RemoveAll(buildPath)
commands := []types.Command{
&builder.AddAdditionalEntriesToContext{},
&builder.HardwareLoader{},
&builder.ToolsLoader{},
&builder.TargetBoardResolver{},
&builder.SketchLoader{},
&builder.SetupBuildProperties{},
}
for _, command := range commands {
err := command.Run(ctx)
NoError(t, err)
}
buildProperties := ctx.BuildProperties
require.Equal(t, "ARDUINO", buildProperties[constants.BUILD_PROPERTIES_SOFTWARE])
require.Equal(t, "uno", buildProperties[constants.ID])
require.Equal(t, "Arduino/Genuino Uno", buildProperties["name"])
require.Equal(t, "0x2341", buildProperties["vid.0"])
require.Equal(t, "\"{compiler.path}{compiler.c.cmd}\" {compiler.c.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {compiler.c.extra_flags} {build.extra_flags} {includes} \"{source_file}\" -o \"{object_file}\"", buildProperties["recipe.c.o.pattern"])
require.Equal(t, "{path}/etc/avrdude.conf", buildProperties["tools.avrdude.config.path"])
require.Equal(t, Abs(t, "downloaded_hardware/arduino/avr"), buildProperties[constants.BUILD_PROPERTIES_RUNTIME_PLATFORM_PATH])
require.Equal(t, Abs(t, "downloaded_hardware/arduino"), buildProperties[constants.BUILD_PROPERTIES_RUNTIME_HARDWARE_PATH])
require.Equal(t, "10600", buildProperties[constants.BUILD_PROPERTIES_RUNTIME_IDE_VERSION])
require.NotEmpty(t, buildProperties[constants.BUILD_PROPERTIES_RUNTIME_OS])
require.Equal(t, Abs(t, "./downloaded_tools/arm-none-eabi-gcc/4.8.3-2014q1"), buildProperties["runtime.tools.arm-none-eabi-gcc.path"])
require.Equal(t, Abs(t, "./downloaded_tools/arm-none-eabi-gcc/4.8.3-2014q1"), buildProperties["runtime.tools.arm-none-eabi-gcc-4.8.3-2014q1.path"])
require.Equal(t, Abs(t, "./downloaded_tools/bossac/1.6.1-arduino"), buildProperties["runtime.tools.bossac-1.6.1-arduino.path"])
require.Equal(t, Abs(t, "./downloaded_tools/bossac/1.5-arduino"), buildProperties["runtime.tools.bossac-1.5-arduino.path"])
require.True(t, buildProperties["runtime.tools.bossac.path"] == Abs(t, "./downloaded_tools/bossac/1.6.1-arduino") || buildProperties["runtime.tools.bossac.path"] == Abs(t, "./downloaded_tools/bossac/1.5-arduino"))
require.Equal(t, Abs(t, "./downloaded_tools/avrdude/6.0.1-arduino5"), buildProperties["runtime.tools.avrdude.path"])
require.Equal(t, Abs(t, "./downloaded_tools/avrdude/6.0.1-arduino5"), buildProperties["runtime.tools.avrdude-6.0.1-arduino5.path"])
require.Equal(t, Abs(t, "./downloaded_tools/avr-gcc/4.8.1-arduino5"), buildProperties["runtime.tools.avr-gcc.path"])
require.Equal(t, Abs(t, "./downloaded_tools/avr-gcc/4.8.1-arduino5"), buildProperties["runtime.tools.avr-gcc-4.8.1-arduino5.path"])
require.Equal(t, Abs(t, "sketch1"), buildProperties[constants.BUILD_PROPERTIES_SOURCE_PATH])
require.True(t, utils.MapStringStringHas(buildProperties, constants.BUILD_PROPERTIES_EXTRA_TIME_UTC))
require.True(t, utils.MapStringStringHas(buildProperties, constants.BUILD_PROPERTIES_EXTRA_TIME_LOCAL))
require.True(t, utils.MapStringStringHas(buildProperties, constants.BUILD_PROPERTIES_EXTRA_TIME_ZONE))
require.True(t, utils.MapStringStringHas(buildProperties, constants.BUILD_PROPERTIES_EXTRA_TIME_DST))
}
func TestParseTLSWithEnvironmentVariables(t *testing.T) {
config := configure(fmt.Sprintf(`{
"server": {
"tls_cert_file": "%s",
"client_ca_file": "nosuchfile"
}
}`, Cert))
vars := map[string]string{
"SERVER_TLS_KEY_FILE": Key,
"SERVER_CLIENT_CA_FILE": Root,
}
setupEnvironmentVariables(t, vars)
defer cleanupEnvironmentVariables(t, vars)
tlsConfig, err := ParseServerTLS(config, true)
require.NoError(t, err)
expectedCert, err := tls.LoadX509KeyPair(Cert, Key)
require.NoError(t, err)
expectedRoot, err := trustmanager.LoadCertFromFile(Root)
require.NoError(t, err)
require.Len(t, tlsConfig.Certificates, 1)
require.True(t, reflect.DeepEqual(expectedCert, tlsConfig.Certificates[0]))
subjects := tlsConfig.ClientCAs.Subjects()
require.Len(t, subjects, 1)
require.True(t, bytes.Equal(expectedRoot.RawSubject, subjects[0]))
require.Equal(t, tlsConfig.ClientAuth, tls.RequireAndVerifyClientCert)
}
func TestRDBTUFKeyJSONUnmarshalling(t *testing.T) {
rdb := RDBKey{
Timing: rethinkdb.Timing{
CreatedAt: time.Now().AddDate(-1, -1, -1),
UpdatedAt: time.Now().AddDate(0, -5, 0),
DeletedAt: time.Time{},
},
Gun: "namespaced/name",
Role: "timestamp",
Cipher: "ecdsa",
Public: []byte("Hello world"),
}
jsonBytes, err := json.Marshal(rdb)
require.NoError(t, err)
unmarshalledAnon, err := PubKeysRethinkTable.JSONUnmarshaller(jsonBytes)
require.NoError(t, err)
unmarshalled, ok := unmarshalledAnon.(RDBKey)
require.True(t, ok)
// There is some weirdness with comparing time.Time due to a location pointer,
// so let's use time.Time's equal function to compare times, and then re-assign
// the timing struct to compare the rest of the RDBTUFFile struct
require.True(t, rdb.CreatedAt.Equal(unmarshalled.CreatedAt))
require.True(t, rdb.UpdatedAt.Equal(unmarshalled.UpdatedAt))
require.True(t, rdb.DeletedAt.Equal(unmarshalled.DeletedAt))
unmarshalled.Timing = rdb.Timing
require.Equal(t, rdb, unmarshalled)
}
func TestSpecOptional2OptionChoice(t *testing.T) {
var f, g *bool
init := func(c *Cmd) {
f = c.BoolOpt("f", false, "")
g = c.BoolOpt("g", false, "")
}
spec := "[-f|-g]"
okCmd(t, spec, init, []string{})
require.False(t, *f)
require.False(t, *g)
okCmd(t, spec, init, []string{"-f"})
require.True(t, *f)
require.False(t, *g)
okCmd(t, spec, init, []string{"-g"})
require.False(t, *f)
require.True(t, *g)
badCases := [][]string{
{"-s"},
{"-f", "-g"},
{"-g", "-f"},
{"-f", "xxx"},
{"xxx", "-f"},
}
for _, args := range badCases {
failCmd(t, spec, init, args)
}
}
// Checks that the DB contains the expected keys, and returns a map of the GormPrivateKey object by key ID
func requireExpectedRDBKeys(t *testing.T, dbStore *RethinkDBKeyStore, expectedKeys []data.PrivateKey) map[string]RDBPrivateKey {
res, err := gorethink.DB(dbStore.dbName).Table(PrivateKeysRethinkTable.Name).Run(dbStore.sess)
require.NoError(t, err)
var rows []RDBPrivateKey
require.NoError(t, res.All(&rows))
require.Len(t, rows, len(expectedKeys))
result := make(map[string]RDBPrivateKey)
for _, rdbKey := range rows {
result[rdbKey.KeyID] = rdbKey
}
for _, key := range expectedKeys {
rdbKey, ok := result[key.ID()]
require.True(t, ok)
require.NotNil(t, rdbKey)
require.Equal(t, key.Public(), rdbKey.Public)
require.Equal(t, key.Algorithm(), rdbKey.Algorithm)
// because we have to manually set the created and modified times
require.True(t, rdbKey.CreatedAt.Equal(rdbNow))
require.True(t, rdbKey.UpdatedAt.Equal(rdbNow))
require.True(t, rdbKey.DeletedAt.Equal(time.Time{}))
}
return result
}
func TestSpecBoolOpt(t *testing.T) {
var f *bool
init := func(c *Cmd) {
f = c.BoolOpt("f force", false, "")
}
spec := "-f"
okCmd(t, spec, init, []string{"-f"})
require.True(t, *f)
okCmd(t, spec, init, []string{"--force"})
require.True(t, *f)
okCmd(t, spec, init, []string{"-f=true"})
require.True(t, *f)
okCmd(t, spec, init, []string{"--force=true"})
require.True(t, *f)
okCmd(t, spec, init, []string{"--force=false"})
require.False(t, *f)
badCases := [][]string{
{},
{"-g"},
{"-f", "-g"},
{"-g", "-f"},
{"-f", "true"},
{"-f", "xxx"},
{"xxx", "-f"},
}
for _, args := range badCases {
failCmd(t, spec, init, args)
}
}
func TestSetupBuildPropertiesWithMissingPropsFromParentPlatformTxtFiles(t *testing.T) {
DownloadCoresAndToolsAndLibraries(t)
context := make(map[string]interface{})
buildPath := SetupBuildPath(t, context)
defer os.RemoveAll(buildPath)
context[constants.CTX_BUILD_PROPERTIES_RUNTIME_IDE_VERSION] = "10600"
context[constants.CTX_HARDWARE_FOLDERS] = []string{filepath.Join("..", "hardware"), "hardware", "downloaded_hardware", "user_hardware"}
context[constants.CTX_TOOLS_FOLDERS] = []string{"downloaded_tools", "./tools_builtin"}
context[constants.CTX_FQBN] = "my_avr_platform:avr:custom_yun"
context[constants.CTX_SKETCH_LOCATION] = filepath.Join("sketch1", "sketch.ino")
commands := []types.Command{
&builder.SetupHumanLoggerIfMissing{},
&builder.ContainerSetupHardwareToolsLibsSketchAndProps{},
}
for _, command := range commands {
err := command.Run(context)
NoError(t, err)
}
buildProperties := context[constants.CTX_BUILD_PROPERTIES].(props.PropertiesMap)
require.Equal(t, "ARDUINO", buildProperties[constants.BUILD_PROPERTIES_SOFTWARE])
require.Equal(t, "custom_yun", buildProperties[constants.ID])
require.Equal(t, "Arduino Yún", buildProperties["name"])
require.Equal(t, "0x2341", buildProperties["vid.0"])
require.Equal(t, "\"{compiler.path}{compiler.c.cmd}\" {compiler.c.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {compiler.c.extra_flags} {build.extra_flags} {includes} \"{source_file}\" -o \"{object_file}\"", buildProperties["recipe.c.o.pattern"])
require.Equal(t, "{path}/etc/avrdude.conf", buildProperties["tools.avrdude.config.path"])
coanProps := buildProperties.SubTree(constants.BUILD_PROPERTIES_TOOLS_KEY).SubTree(constants.COAN)
require.Equal(t, "{path}/coan", coanProps["cmd.path"])
require.Equal(t, "\"{cmd.path}\" source -m -E -P -kb {compiler.c.flags} -mmcu={build.mcu} -DF_CPU={build.f_cpu} -DARDUINO={runtime.ide.version} -DARDUINO_{build.board} -DARDUINO_ARCH_{build.arch} {compiler.c.extra_flags} {build.extra_flags} \"{source_file}\"", coanProps[constants.BUILD_PROPERTIES_PATTERN])
require.Equal(t, Abs(t, "user_hardware/my_avr_platform/avr"), buildProperties[constants.BUILD_PROPERTIES_RUNTIME_PLATFORM_PATH])
require.Equal(t, Abs(t, "user_hardware/my_avr_platform"), buildProperties[constants.BUILD_PROPERTIES_RUNTIME_HARDWARE_PATH])
require.Equal(t, "10600", buildProperties[constants.CTX_BUILD_PROPERTIES_RUNTIME_IDE_VERSION])
require.NotEmpty(t, buildProperties[constants.BUILD_PROPERTIES_RUNTIME_OS])
require.Equal(t, Abs(t, "./downloaded_tools/arm-none-eabi-gcc/4.8.3-2014q1"), buildProperties["runtime.tools.arm-none-eabi-gcc.path"])
require.Equal(t, Abs(t, "./downloaded_tools/arm-none-eabi-gcc/4.8.3-2014q1"), buildProperties["runtime.tools.arm-none-eabi-gcc-4.8.3-2014q1.path"])
require.Equal(t, Abs(t, "./downloaded_tools/bossac/1.6.1-arduino"), buildProperties["runtime.tools.bossac-1.6.1-arduino.path"])
require.Equal(t, Abs(t, "./downloaded_tools/bossac/1.5-arduino"), buildProperties["runtime.tools.bossac-1.5-arduino.path"])
require.True(t, buildProperties["runtime.tools.bossac.path"] == Abs(t, "./downloaded_tools/bossac/1.6.1-arduino") || buildProperties["runtime.tools.bossac.path"] == Abs(t, "./downloaded_tools/bossac/1.5-arduino"))
require.Equal(t, Abs(t, "./downloaded_tools/avrdude/6.0.1-arduino5"), buildProperties["runtime.tools.avrdude.path"])
require.Equal(t, Abs(t, "./downloaded_tools/avrdude/6.0.1-arduino5"), buildProperties["runtime.tools.avrdude-6.0.1-arduino5.path"])
require.Equal(t, Abs(t, "./downloaded_tools/avr-gcc/4.8.1-arduino5"), buildProperties["runtime.tools.avr-gcc.path"])
require.Equal(t, Abs(t, "./downloaded_tools/avr-gcc/4.8.1-arduino5"), buildProperties["runtime.tools.avr-gcc-4.8.1-arduino5.path"])
require.Equal(t, Abs(t, "sketch1"), buildProperties[constants.BUILD_PROPERTIES_SOURCE_PATH])
require.True(t, utils.MapStringStringHas(buildProperties, constants.BUILD_PROPERTIES_EXTRA_TIME_UTC))
require.True(t, utils.MapStringStringHas(buildProperties, constants.BUILD_PROPERTIES_EXTRA_TIME_LOCAL))
require.True(t, utils.MapStringStringHas(buildProperties, constants.BUILD_PROPERTIES_EXTRA_TIME_ZONE))
require.True(t, utils.MapStringStringHas(buildProperties, constants.BUILD_PROPERTIES_EXTRA_TIME_DST))
}
// testUnfinishedBuild verifies that we can write a build which is not yet
// finished, load the build back from the database, and update it when it
// finishes.
func testUnfinishedBuild(t *testing.T) {
d := clearDB(t)
defer d.Close(t)
// Load the test repo.
tr := util.NewTempRepo()
defer tr.Cleanup()
repos := gitinfo.NewRepoMap(tr.Dir)
// Obtain and insert an unfinished build.
httpClient = testHttpClient
b, err := getBuildFromMaster("client.skia", "Test-Ubuntu12-ShuttleA-GTX550Ti-x86_64-Release-Valgrind", 152, repos)
assert.Nil(t, err)
assert.False(t, b.IsFinished(), fmt.Errorf("Unfinished build thinks it's finished!"))
dbSerializeAndCompare(t, b, true)
// Ensure that the build is found by getUnfinishedBuilds.
unfinished, err := getUnfinishedBuilds()
assert.Nil(t, err)
found := false
for _, u := range unfinished {
if u.Master == b.Master && u.Builder == b.Builder && u.Number == b.Number {
found = true
break
}
}
assert.True(t, found, "Unfinished build was not found by getUnfinishedBuilds!")
// Add another step to the build to "finish" it, ensure that we can
// retrieve it as expected.
b.Finished = b.Started + 1000
b.Times[1] = b.Finished
stepStarted := b.Started + 500
s := &BuildStep{
BuildID: b.Id,
Name: "LastStep",
Times: []float64{stepStarted, b.Finished},
Number: len(b.Steps),
Results: 0,
ResultsRaw: []interface{}{0.0, []interface{}{}},
Started: b.Started + 500.0,
Finished: b.Finished,
}
b.Steps = append(b.Steps, s)
assert.True(t, b.IsFinished(), "Finished build thinks it's unfinished!")
dbSerializeAndCompare(t, b, true)
// Ensure that the finished build is NOT found by getUnfinishedBuilds.
unfinished, err = getUnfinishedBuilds()
assert.Nil(t, err)
found = false
for _, u := range unfinished {
if u.Master == b.Master && u.Builder == b.Builder && u.Number == b.Number {
found = true
break
}
}
assert.False(t, found, "Finished build was found by getUnfinishedBuilds!")
}
func TestExternalFile(t *testing.T) {
f, err := ioutil.TempFile("", "")
if err != nil {
t.Error(err)
}
defer os.Remove(f.Name())
nodesApi := externalCadvisorNodes{hostsFile: f.Name(), nodes: nil}
testData := &NodeList{
Items: map[Host]Info{
Host("host1"): {PublicIP: "1.2.3.4", InternalIP: "1.2.3.4"},
Host("host2"): {PublicIP: "1.2.3.5", InternalIP: "1.2.3.5"},
},
}
require.NoError(t, writeMarshaledData(f, externalizeNodes(testData)))
res, err := nodesApi.List()
require.NoError(t, err)
require.True(t, reflect.DeepEqual(res, testData), "failure. Expected: %+v, got: %+v", res, testData)
testData.Items[Host("host3")] = Info{PublicIP: "2.2.2.2", InternalIP: "2.2.2.2"}
require.NoError(t, writeMarshaledData(f, externalizeNodes(testData)))
res, err = nodesApi.List()
require.NoError(t, err)
require.True(t, reflect.DeepEqual(res, testData), "failure. Expected: %+v, got: %+v", res, testData)
}
// This modifies the metadata so that the signed part has an extra, extraneous
// field. This does not prevent it from being unmarshalled as Signed* object,
// but the signature is no longer valid because the hash is different.
func TestSwizzlerInvalidateMetadataSignatures(t *testing.T) {
f, origMeta := createNewSwizzler(t)
f.InvalidateMetadataSignatures(data.CanonicalRootRole)
for role, metaBytes := range origMeta {
newMeta, err := f.MetadataCache.GetMeta(role, -1)
require.NoError(t, err)
if role != data.CanonicalRootRole {
require.True(t, bytes.Equal(metaBytes, newMeta), "bytes have changed for role %s", role)
} else {
require.False(t, bytes.Equal(metaBytes, newMeta))
// it be JSON unmarshallable into a data.Signed, and it's signed by
// root, but it is NOT the correct signature because the hash
// does not match
origSigned, newSigned := &data.Signed{}, &data.Signed{}
require.NoError(t, json.Unmarshal(metaBytes, origSigned))
require.NoError(t, json.Unmarshal(newMeta, newSigned))
require.Len(t, newSigned.Signatures, len(origSigned.Signatures))
for i := range origSigned.Signatures {
require.Equal(t, origSigned.Signatures[i].KeyID, newSigned.Signatures[i].KeyID)
require.Equal(t, origSigned.Signatures[i].Method, newSigned.Signatures[i].Method)
require.NotEqual(t, origSigned.Signatures[i].Signature, newSigned.Signatures[i].Signature)
require.Equal(t, []byte("invalid signature"), newSigned.Signatures[i].Signature)
}
require.True(t, bytes.Equal(origSigned.Signed, newSigned.Signed))
}
}
}
// Check that torrent Info is obtained from the metainfo file cache.
func TestAddTorrentMetainfoInCache(t *testing.T) {
cfg := TestingConfig
cfg.DisableMetainfoCache = false
cfg.ConfigDir, _ = ioutil.TempDir(os.TempDir(), "")
defer os.RemoveAll(cfg.ConfigDir)
cl, err := NewClient(&cfg)
require.NoError(t, err)
defer cl.Close()
dir, mi := testutil.GreetingTestTorrent()
defer os.RemoveAll(dir)
tt, new, err := cl.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
require.NoError(t, err)
require.True(t, new)
require.NotNil(t, tt.Info())
_, err = os.Stat(filepath.Join(cfg.ConfigDir, "torrents", fmt.Sprintf("%x.torrent", mi.Info.Hash)))
require.NoError(t, err)
// Contains only the infohash.
var ts TorrentSpec
missinggo.CopyExact(&ts.InfoHash, mi.Info.Hash)
_, ok := cl.Torrent(ts.InfoHash)
require.True(t, ok)
tt.Drop()
_, ok = cl.Torrent(ts.InfoHash)
require.False(t, ok)
tt, new, err = cl.AddTorrentSpec(&ts)
require.NoError(t, err)
require.True(t, new)
// Obtained from the metainfo cache.
require.NotNil(t, tt.Info())
}
func TestIntCompare(t *testing.T) {
require.True(t, intCompare(1, query.EQ, "1"))
require.False(t, intCompare(1, query.EQ, "2"))
require.True(t, intCompare(2, query.GT, "1"))
require.False(t, intCompare(1, query.GT, "1"))
}
func TestBoolArg(t *testing.T) {
cmd := &Cmd{argsIdx: map[string]*arg{}}
a := cmd.Bool(BoolArg{Name: "a", Value: true, Desc: ""})
require.True(t, *a)
os.Setenv("B", "")
b := cmd.Bool(BoolArg{Name: "b", Value: false, EnvVar: "B", Desc: ""})
require.False(t, *b)
trueValues := []string{"1", "true", "TRUE"}
for _, tv := range trueValues {
os.Setenv("B", tv)
b = cmd.Bool(BoolArg{Name: "b", Value: false, EnvVar: "B", Desc: ""})
require.True(t, *b, "env=%s", tv)
}
falseValues := []string{"0", "false", "FALSE", "xyz"}
for _, tv := range falseValues {
os.Setenv("B", tv)
b = cmd.Bool(BoolArg{Name: "b", Value: false, EnvVar: "B", Desc: ""})
require.False(t, *b, "env=%s", tv)
}
os.Setenv("B", "")
os.Setenv("C", "false")
os.Setenv("D", "true")
b = cmd.Bool(BoolArg{Name: "b", Value: true, EnvVar: "B C D", Desc: ""})
require.False(t, *b)
}
func TestDetectImagesInitialDetect(t *testing.T) {
manager, fakeRuntime, _ := newRealImageManager(ImageGCPolicy{})
fakeRuntime.ImageList = []container.Image{
makeImage(0, 1024),
makeImage(1, 2048),
}
fakeRuntime.AllPodList = []*container.Pod{
{
Containers: []*container.Container{
makeContainer(1),
},
},
}
startTime := time.Now().Add(-time.Millisecond)
err := manager.detectImages(zero)
assert := assert.New(t)
require.NoError(t, err)
assert.Equal(manager.imageRecordsLen(), 2)
noContainer, ok := manager.getImageRecord(imageName(0))
require.True(t, ok)
assert.Equal(zero, noContainer.firstDetected)
assert.Equal(zero, noContainer.lastUsed)
withContainer, ok := manager.getImageRecord(imageName(1))
require.True(t, ok)
assert.Equal(zero, withContainer.firstDetected)
assert.True(withContainer.lastUsed.After(startTime))
}
func TestParseTLSWithTLS(t *testing.T) {
config := configure(fmt.Sprintf(`{
"server": {
"tls_cert_file": "%s",
"tls_key_file": "%s",
"client_ca_file": "%s"
}
}`, Cert, Key, Root))
tlsConfig, err := ParseServerTLS(config, false)
require.NoError(t, err)
expectedCert, err := tls.LoadX509KeyPair(Cert, Key)
require.NoError(t, err)
expectedRoot, err := trustmanager.LoadCertFromFile(Root)
require.NoError(t, err)
require.Len(t, tlsConfig.Certificates, 1)
require.True(t, reflect.DeepEqual(expectedCert, tlsConfig.Certificates[0]))
subjects := tlsConfig.ClientCAs.Subjects()
require.Len(t, subjects, 1)
require.True(t, bytes.Equal(expectedRoot.RawSubject, subjects[0]))
require.Equal(t, tlsConfig.ClientAuth, tls.RequireAndVerifyClientCert)
}
func TestDonateHard(t *testing.T) {
//common.InitDefaultLogging(true)
var (
start = ip("10.0.1.0")
size address.Offset = 48
)
// Fill a fresh space
spaceset := makeSpace(start, size)
for i := address.Offset(0); i < size; i++ {
ok, _ := spaceset.Allocate(address.NewRange(start, size))
require.True(t, ok, "Failed to get IP!")
}
require.Equal(t, address.Offset(0), spaceset.NumFreeAddresses())
// Now free all but the last address
// this will force us to split the free list
for i := address.Offset(0); i < size-1; i++ {
require.NoError(t, spaceset.Free(address.Add(start, i)))
}
// Now split
newRange, ok := spaceset.Donate(address.NewRange(start, size))
require.True(t, ok, "GiveUpSpace result")
require.Equal(t, ip("10.0.1.23"), newRange.Start)
require.Equal(t, address.Offset(24), newRange.Size())
require.Equal(t, address.Offset(23), spaceset.NumFreeAddresses())
//Space set should now have 2 spaces
expected := New()
expected.Add(start, 23)
expected.ours = add(nil, ip("10.0.1.47"), ip("10.0.1.48"))
require.Equal(t, expected, spaceset)
}
func TestLoadSketch(t *testing.T) {
context := make(map[string]interface{})
context[constants.CTX_SKETCH_LOCATION] = filepath.Join("sketch1", "sketch.ino")
commands := []types.Command{
&builder.SetupHumanLoggerIfMissing{},
&builder.SketchLoader{},
}
for _, command := range commands {
err := command.Run(context)
NoError(t, err)
}
sketch := context[constants.CTX_SKETCH].(*types.Sketch)
require.NotNil(t, sketch)
require.True(t, strings.Index(sketch.MainFile.Name, "sketch.ino") != -1)
require.Equal(t, 2, len(sketch.OtherSketchFiles))
require.True(t, strings.Index(sketch.OtherSketchFiles[0].Name, "old.pde") != -1)
require.True(t, strings.Index(sketch.OtherSketchFiles[1].Name, "other.ino") != -1)
require.Equal(t, 2, len(sketch.AdditionalFiles))
require.True(t, strings.Index(sketch.AdditionalFiles[0].Name, "header.h") != -1)
require.True(t, strings.Index(sketch.AdditionalFiles[1].Name, "helper.h") != -1)
}