// Test SessionLogin
func TestSessionLogin(t *testing.T) {
var (
c *ICSPClient
)
if os.Getenv("ICSP_TEST_ACCEPTANCE") == "true" {
_, c = getTestDriverA()
if c == nil {
t.Fatalf("Failed to execute getTestDriver() ")
}
data, err := c.SessionLogin()
// fmt.Printf("after SessionLogin: %s -> (err) %+v", data.ID, err)
assert.NoError(t, err, "SessionLogin threw error -> %s", err)
assert.NotEmpty(t, data.ID, fmt.Sprintf("SessionLogin is empty! something went wrong, err -> %s, data -> %+v\n", err, data))
assert.Equal(t, "none", c.APIKey)
c.APIKey = data.ID
err = c.SessionLogout()
assert.NoError(t, err, "SessionLogout threw error -> %s", err)
data, err = c.SessionLogin()
assert.NoError(t, err, "SessionLogin threw error -> %s", err)
} else {
_, c = getTestDriverU()
data, err := c.SessionLogin()
assert.Error(t, err, fmt.Sprintf("ALL ok, no error, caught as expected: %s,%+v\n", err, data))
assert.Equal(t, "none", c.APIKey)
}
}
func TestTypeResolver_AdditionalItems(t *testing.T) {
_, resolver, err := basicTaskListResolver(t)
tpe := spec.StringProperty()
if assert.NoError(t, err) {
// arrays of primitives and string formats with additional formats
for _, val := range schTypeVals {
var sch spec.Schema
sch.Typed(val.Type, val.Format)
var coll spec.Schema
coll.Type = []string{"array"}
coll.Items = new(spec.SchemaOrArray)
coll.Items.Schema = tpe
coll.AdditionalItems = new(spec.SchemaOrBool)
coll.AdditionalItems.Schema = &sch
rt, err := resolver.ResolveSchema(&coll, true)
if assert.NoError(t, err) && assert.True(t, rt.IsArray) {
assert.True(t, rt.HasAdditionalItems)
assert.False(t, rt.IsNullable)
//if assert.NotNil(t, rt.ElementType) {
//assertPrimitiveResolve(t, "string", "", "string", *rt.ElementType)
//}
}
}
}
}
func testAtomicPut(t *testing.T, kv store.Store) {
key := "testAtomicPut"
value := []byte("world")
// Put the key
err := kv.Put(key, value, nil)
assert.NoError(t, err)
// Get should return the value and an incremented index
pair, err := kv.Get(key)
assert.NoError(t, err)
if assert.NotNil(t, pair) {
assert.NotNil(t, pair.Value)
}
assert.Equal(t, pair.Value, value)
assert.NotEqual(t, pair.LastIndex, 0)
// This CAS should fail: previous exists.
success, _, err := kv.AtomicPut(key, []byte("WORLD"), nil, nil)
assert.Error(t, err)
assert.False(t, success)
// This CAS should succeed
success, _, err = kv.AtomicPut(key, []byte("WORLD"), pair, nil)
assert.NoError(t, err)
assert.True(t, success)
// This CAS should fail, key exists.
pair.LastIndex = 6744
success, _, err = kv.AtomicPut(key, []byte("WORLDWORLD"), pair, nil)
assert.Error(t, err)
assert.False(t, success)
}
func TestCollect(t *testing.T) {
cm := &collectorManager{}
firstTime := time.Now().Add(-time.Hour)
secondTime := time.Now().Add(time.Hour)
f1 := &fakeCollector{
nextCollectionTime: firstTime,
}
f2 := &fakeCollector{
nextCollectionTime: secondTime,
}
assert := assert.New(t)
assert.NoError(cm.RegisterCollector(f1))
assert.NoError(cm.RegisterCollector(f2))
// First collection, everyone gets collected from.
nextTime, _, err := cm.Collect()
assert.Equal(firstTime, nextTime)
assert.NoError(err)
assert.Equal(1, f1.collectedFrom)
assert.Equal(1, f2.collectedFrom)
f1.nextCollectionTime = time.Now().Add(2 * time.Hour)
// Second collection, only the one that is ready gets collected from.
nextTime, _, err = cm.Collect()
assert.Equal(secondTime, nextTime)
assert.NoError(err)
assert.Equal(2, f1.collectedFrom)
assert.Equal(1, f2.collectedFrom)
}
func TestDNSProvider_Present(t *testing.T) {
os.Setenv("LINODE_API_KEY", "testing")
defer restoreEnv()
p, err := NewDNSProvider()
assert.NoError(t, err)
domain := "example.com"
keyAuth := "dGVzdGluZw=="
mockResponses := MockResponseMap{
"domain.list": MockResponse{
Response: []dns.Domain{
dns.Domain{
Domain: domain,
DomainID: 1234,
},
},
},
"domain.resource.create": MockResponse{
Response: dns.ResourceResponse{
ResourceID: 1234,
},
},
}
mockSrv := newMockServer(t, mockResponses)
defer mockSrv.Close()
p.linode.ToLinode().SetEndpoint(mockSrv.URL)
err = p.Present(domain, "", keyAuth)
assert.NoError(t, err)
}
func TestResurrectStmtSqlMockNoTicker(t *testing.T) {
db, mock, err := sqlmock.New()
if err != nil {
t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
}
defer db.Close()
mock.ExpectPrepare("INSERT INTO `xtable` \\(`path`,`value`\\) VALUES .+").
ExpectExec().WithArgs("gopher", 3141).WillReturnResult(sqlmock.NewResult(1, 1))
tw := newTypeWriterMocked(db)
assert.NoError(t, tw.Save("gopher", 3141))
assert.False(t, tw.Write.IsIdle())
assert.NoError(t, tw.Write.StopIdleChecker())
mock.ExpectPrepare("INSERT INTO `xtable` \\(`path`,`value`\\) VALUES .+").
ExpectExec().WithArgs("gopher", 3144).WillReturnResult(sqlmock.NewResult(1, 1))
assert.NoError(t, tw.Save("gopher", 3144))
// we make sure that all expectations were met
if err := mock.ExpectationsWereMet(); err != nil {
t.Errorf("there were unfulfilled expections: %s", err)
}
}
func Test_Transport_FetchSpec(t *testing.T) {
// t.Skip()
root := "Spec"
halt, tree, ml, _, tr := seed(t, root)
defer halt()
mx, err := ml.FeedManifests(true, true, true, lists.NewFileList().ListDir(tree.CWD)...)
assert.NoError(t, err)
err = tr.Upload(mx)
assert.NoError(t, err)
// make spec
nameMap := map[string]proto.ID{}
for name, m := range mx {
nameMap[name] = m.ID
}
spec1, err := proto.NewSpec(time.Now().UnixNano(), nameMap, []string{})
assert.NoError(t, err)
err = tr.UploadSpec(spec1)
assert.NoError(t, err)
spec2, err := tr.GetSpec(spec1.ID)
assert.NoError(t, err)
assert.Equal(t, spec1.ID, spec2.ID)
}
func TestEnum_ComputeInstance(t *testing.T) {
// ensure that the enum validation for the anonymous object under the delegate property
// is rendered.
specDoc, err := spec.Load("../fixtures/codegen/todolist.enums.yml")
if assert.NoError(t, err) {
definitions := specDoc.Spec().Definitions
k := "ComputeInstance"
schema := definitions[k]
genModel, err := makeGenDefinition(k, "models", schema, specDoc)
if assert.NoError(t, err) {
buf := bytes.NewBuffer(nil)
err := modelTemplate.Execute(buf, genModel)
if assert.NoError(t, err) {
ff, err := formatGoFile("object_thing.go", buf.Bytes())
if assert.NoError(t, err) {
res := string(ff)
fmt.Println(res)
assertInCode(t, "Region string `json:\"region,omitempty\"`", res)
assertInCode(t, "var computeInstanceRegionEnum []interface{}", res)
assertInCode(t, "m.validateRegionEnum(\"region\", \"body\", m.Region)", res)
}
}
}
}
}
func TestEnum_NewPrototype(t *testing.T) {
// ensure that the enum validation for the anonymous object under the delegate property
// is rendered.
specDoc, err := spec.Load("../fixtures/codegen/todolist.enums.yml")
if assert.NoError(t, err) {
definitions := specDoc.Spec().Definitions
k := "NewPrototype"
schema := definitions[k]
genModel, err := makeGenDefinition(k, "models", schema, specDoc)
if assert.NoError(t, err) {
buf := bytes.NewBuffer(nil)
err := modelTemplate.Execute(buf, genModel)
if assert.NoError(t, err) {
ff, err := formatGoFile("object_thing.go", buf.Bytes())
if assert.NoError(t, err) {
res := string(ff)
assertInCode(t, "ActivatingUser NewPrototypeActivatingUser `json:\"activating_user,omitempty\"`", res)
assertInCode(t, "Delegate NewPrototypeDelegate `json:\"delegate\"`", res)
assertInCode(t, "Role string `json:\"role\"`", res)
assertInCode(t, "var newPrototypeRoleEnum []interface{}", res)
assertInCode(t, "var newPrototypeDelegateKindEnum []interface{}", res)
assertInCode(t, "m.validateDelegate(formats)", res)
assertInCode(t, "m.validateRole(formats)", res)
assertInCode(t, "m.validateActivatingUser(formats)", res)
assertInCode(t, "m.Delegate.Validate(formats)", res)
assertInCode(t, "m.ActivatingUser.Validate(formats)", res)
}
}
}
}
}
func TestEnum_SliceAndAdditionalItemsThing(t *testing.T) {
specDoc, err := spec.Load("../fixtures/codegen/todolist.enums.yml")
if assert.NoError(t, err) {
definitions := specDoc.Spec().Definitions
k := "SliceAndAdditionalItemsThing"
schema := definitions[k]
genModel, err := makeGenDefinition(k, "models", schema, specDoc)
if assert.NoError(t, err) {
buf := bytes.NewBuffer(nil)
err := modelTemplate.Execute(buf, genModel)
if assert.NoError(t, err) {
ff, err := formatGoFile("slice_and_additional_items_thing.go", buf.Bytes())
if assert.NoError(t, err) {
res := string(ff)
assertInCode(t, "var sliceAndAdditionalItemsThingEnum []interface{}", res)
assertInCode(t, k+") validateSliceAndAdditionalItemsThingEnum(path, location string, value SliceAndAdditionalItemsThing)", res)
//assertInCode(t, "m.validateSliceAndAdditionalItemsThingEnum(\"\", \"body\", m)", res)
assertInCode(t, "var sliceAndAdditionalItemsThingP0Enum []interface{}", res)
assertInCode(t, k+") validateP0Enum(path, location string, value string)", res)
assertInCode(t, "m.validateP0Enum(\"0\", \"body\", m.P0)", res)
assertInCode(t, "var sliceAndAdditionalItemsThingItemsEnum []interface{}", res)
assertInCode(t, k+") validateSliceAndAdditionalItemsThingItemsEnum(path, location string, value float32)", res)
assertInCode(t, "m.validateSliceAndAdditionalItemsThingItemsEnum(strconv.Itoa(i+1), \"body\", m.SliceAndAdditionalItemsThingItems[i])", res)
}
}
}
}
}
func TestEnum_MapThing(t *testing.T) {
specDoc, err := spec.Load("../fixtures/codegen/todolist.enums.yml")
if assert.NoError(t, err) {
definitions := specDoc.Spec().Definitions
k := "MapThing"
schema := definitions[k]
genModel, err := makeGenDefinition(k, "models", schema, specDoc)
if assert.NoError(t, err) {
buf := bytes.NewBuffer(nil)
err := modelTemplate.Execute(buf, genModel)
if assert.NoError(t, err) {
ff, err := formatGoFile("map_thing.go", buf.Bytes())
if assert.NoError(t, err) {
res := string(ff)
assertInCode(t, "var mapThingEnum []interface{}", res)
assertInCode(t, k+") validateMapThingEnum(path, location string, value map[string]string)", res)
assertInCode(t, "m.validateMapThingEnum(\"\", \"body\", m)", res)
assertInCode(t, "var mapThingValueEnum []interface{}", res)
assertInCode(t, k+") validateMapThingValueEnum(path, location string, value string)", res)
assertInCode(t, "m.validateMapThingValueEnum(k, \"body\", m[k])", res)
}
}
}
}
}
func addTarget(t *testing.T, repo *NotaryRepository, targetName, targetFile string) *Target {
target, err := NewTarget(targetName, targetFile)
assert.NoError(t, err, "error creating target")
err = repo.AddTarget(target)
assert.NoError(t, err, "error adding target")
return target
}
// Test for expired key and see if RefreshLogin can restore the key if we have a bad key
func TestSessionExpiredKey(t *testing.T) {
var (
c *ICSPClient
d *ICSPTest
)
if os.Getenv("ONEVIEW_TEST_ACCEPTANCE") == "true" {
d, c = getTestDriverA()
if c == nil {
t.Fatalf("Failed to execute getTestDriver() ")
}
err := c.RefreshLogin()
log.Debugf(" login key -> %s", c.APIKey)
assert.NoError(t, err, "RefreshLogin threw error -> %s", err)
// force key to timeout
err = c.SetIdleTimeout(800)
assert.NoError(t, err, "SetIdleTimeout threw error -> %s", err)
// 1 millisecond and we should be timeout with the current key
time.Sleep(1 * time.Millisecond)
// verify we are timed out
_, err = c.GetIdleTimeout()
assert.Error(t, err, "should be 404 not found -> %s ", err)
// verify that we can access something from icps with this client
// This should not fail because it uses RefreshLogin to get a new login session and avoid timeout
serialNumber := d.Tc.GetTestData(d.Env, "SerialNumber").(string)
s, err := c.GetServerBySerialNumber(serialNumber)
assert.NoError(t, err, "GetServerBySerialNumber threw error -> %s, server -> %+v", err, s)
}
}
// Set idle timeout
func TestSetIdleTimeout(t *testing.T) {
var (
c *ICSPClient
// d *ICSPTest
testtime int64
)
if os.Getenv("ONEVIEW_TEST_ACCEPTANCE") == "true" {
testtime = 25000
_, c = getTestDriverA()
if c == nil {
t.Fatalf("Failed to execute getTestDriver() ")
}
err := c.RefreshLogin()
log.Debugf(" login key -> %s", c.APIKey)
assert.NoError(t, err, "RefreshLogin threw error -> %s", err)
err = c.SetIdleTimeout(testtime)
assert.NoError(t, err, "SetIdleTimeout threw error -> %s", err)
timeout, err := c.GetIdleTimeout()
assert.NoError(t, err, "GetIdleTimeout threw error -> %s", err)
assert.Equal(t, testtime, timeout, "Should get timeout equal, %s", timeout)
log.Debugf(" idle timeout -> %d", timeout)
}
}
func doTestPrefixScan(t *testing.T, node Node) {
for i := 1; i < 3; i++ {
n := node.From(fmt.Sprintf("%d%02d", 2015, i))
err := n.Save(&SimpleUser{ID: i, Name: "John"})
assert.NoError(t, err)
}
for i := 1; i < 4; i++ {
n := node.From(fmt.Sprintf("%d%02d", 2016, i))
err := n.Save(&SimpleUser{ID: i, Name: "John"})
assert.NoError(t, err)
}
assert.Len(t, node.PrefixScan("2015"), 2)
assert.Len(t, node.PrefixScan("20"), 5)
buckets2016 := node.PrefixScan("2016")
assert.Len(t, buckets2016, 3)
count, err := buckets2016[1].Count(&SimpleUser{})
assert.NoError(t, err)
assert.Equal(t, 1, count)
assert.NoError(t, buckets2016[1].One("ID", 2, &SimpleUser{}))
}
func TestExecutorDriverError(t *testing.T) {
setTestEnv(t)
// Mock Slave process to respond to registration event.
server := testutil.NewMockSlaveHttpServer(t, func(rsp http.ResponseWriter, req *http.Request) {
reqPath, err := url.QueryUnescape(req.URL.String())
assert.NoError(t, err)
log.Infoln("RCVD request", reqPath)
rsp.WriteHeader(http.StatusAccepted)
})
ch := make(chan bool)
exec := newTestExecutor(t)
exec.ch = ch
exec.t = t
driver := newIntegrationTestDriver(t, exec)
server.Close() // will cause error
// Run() cause async message processing to start
// Therefore, error-handling will be done via Executor.Error callaback.
stat, err := driver.Run()
assert.NoError(t, err)
assert.Equal(t, mesos.Status_DRIVER_STOPPED, stat)
select {
case <-ch:
case <-time.After(time.Millisecond * 5):
log.Errorf("Tired of waiting...")
}
}
func Test_Controller_Stats(t *testing.T) {
repo, controller, mockTCPConn := setupControllerTest(t, 3)
defer cleanupControllerTest(repo)
q, err := repo.GetQueue("test")
assert.NoError(t, err)
cg, err := q.ConsumerGroup("cg1")
assert.NoError(t, err)
cg.GetNext()
cg, err = q.ConsumerGroup("cg2")
assert.NoError(t, err)
cg.GetNext()
cg.GetNext()
err = controller.Stats()
statsResponse := "STAT uptime 0\r\n" +
fmt.Sprintf("STAT time %d\r\n", time.Now().Unix()) +
"STAT version " + repo.Stats.Version + "\r\n" +
"STAT curr_connections 1\r\n" +
"STAT total_connections 1\r\n" +
"STAT cmd_get 0\r\n" +
"STAT cmd_set 0\r\n" +
fmt.Sprintf("STAT queue_test_items %d\r\n", 3) +
"STAT queue_test_open_transactions 0\r\n" +
fmt.Sprintf("STAT queue_test.cg1_items %d\r\n", 2) +
"STAT queue_test.cg1_open_transactions 0\r\n" +
fmt.Sprintf("STAT queue_test.cg2_items %d\r\n", 1) +
"STAT queue_test.cg2_open_transactions 0\r\n" +
"END\r\n"
assert.Nil(t, err)
assert.Equal(t, statsResponse, mockTCPConn.WriteBuffer.String())
}
// TestGenerateSSHKey verifies that SSH key generation does indeed
// generate keys even with keys already exist.
func TestGenerateSSHKey(t *testing.T) {
assert := assert.New(t)
privateKey := generateTempFilePath("private")
publicKey := generateTempFilePath("public")
// Make sure we have no test keys laying around
os.Remove(privateKey)
os.Remove(publicKey)
// Pass case: Sunny day case
err := generateSSHKey(privateKey, publicKey)
assert.NoError(err, "generateSSHKey should not have retuend an error: %s", err)
// Pass case: PrivateKey exists test case
os.Remove(publicKey)
err = generateSSHKey(privateKey, publicKey)
assert.NoError(err, "generateSSHKey should not have retuend an error: %s", err)
// Pass case: PublicKey exists test case
os.Remove(privateKey)
err = generateSSHKey(privateKey, publicKey)
assert.NoError(err, "generateSSHKey should not have retuend an error: %s", err)
// Make sure we have no test keys laying around
os.Remove(privateKey)
os.Remove(publicKey)
// TODO: testing error cases where the file can not be removed?
}
func Test_Transport_Download_Many(t *testing.T) {
// t.Skip()
root := "Download-many"
halt, tree, ml, _, tr := seed(t, root)
defer halt()
assert.NoError(t, tree.PopulateN(10, 1000))
mx, err := ml.FeedManifests(true, true, true, lists.NewFileList().ListDir(tree.CWD)...)
assert.NoError(t, err)
err = tr.Upload(mx)
assert.NoError(t, err)
// Kill some blobs
tree.KillBLOB("file-two.bin")
tree.KillBLOB("one/file-two.bin")
tree.KillBLOB("one/file-three.bin")
req := lists.BlobMap{
"file-two.bin": mx["file-two.bin"],
"one/file-two.bin": mx["one/file-two.bin"],
"one/file-three.bin": mx["one/file-three.bin"],
}
for i := 0; i < 256; i++ {
nm := fmt.Sprintf("big/file-big-%d.bin", i)
tree.KillBLOB(nm)
req[nm] = mx[nm]
}
err = tr.Download(req)
assert.NoError(t, err)
}
func TestUnCompressed(t *testing.T) {
assert := assert.New(t)
// SELECT repeat("a", 50)
before := `
09 00 00 00 03 53 45 4c 45 43 54 20 31 ....SELECT 1
`
after := `
0d 00 00 00 00 00 00 09 00 00 00 03 53 45 4c 45 ............SELE
43 54 20 31 CT 1
`
_, _ = before, after
buf := bytes.NewBufferString("")
buf.Write(DecodeDump(after))
r := NewCompressedReader(buf)
b, err := ioutil.ReadAll(r)
assert.NoError(err)
assert.EqualValues(DecodeDump(before), b)
// write and read again
w := NewCompressedWriter(buf)
_, err = w.Write(DecodeDump(before))
assert.NoError(err)
b, err = ioutil.ReadAll(r)
assert.NoError(err)
assert.EqualValues(DecodeDump(before), b)
}
// TestGetNodeAddresses verifies that proper results are returned
// when requesting node addresses.
func TestGetNodeAddresses(t *testing.T) {
assert := assert.New(t)
fakeNodeClient := fake.NewSimpleClientset(registrytest.MakeNodeList([]string{"node1", "node2"}, api.NodeResources{})).Core().Nodes()
addressProvider := nodeAddressProvider{fakeNodeClient}
// Fail case (no addresses associated with nodes)
nodes, _ := fakeNodeClient.List(api.ListOptions{})
addrs, err := addressProvider.externalAddresses()
assert.Error(err, "addresses should have caused an error as there are no addresses.")
assert.Equal([]string(nil), addrs)
// Pass case with External type IP
nodes, _ = fakeNodeClient.List(api.ListOptions{})
for index := range nodes.Items {
nodes.Items[index].Status.Addresses = []api.NodeAddress{{Type: api.NodeExternalIP, Address: "127.0.0.1"}}
fakeNodeClient.Update(&nodes.Items[index])
}
addrs, err = addressProvider.externalAddresses()
assert.NoError(err, "addresses should not have returned an error.")
assert.Equal([]string{"127.0.0.1", "127.0.0.1"}, addrs)
// Pass case with LegacyHost type IP
nodes, _ = fakeNodeClient.List(api.ListOptions{})
for index := range nodes.Items {
nodes.Items[index].Status.Addresses = []api.NodeAddress{{Type: api.NodeLegacyHostIP, Address: "127.0.0.2"}}
fakeNodeClient.Update(&nodes.Items[index])
}
addrs, err = addressProvider.externalAddresses()
assert.NoError(err, "addresses failback should not have returned an error.")
assert.Equal([]string{"127.0.0.2", "127.0.0.2"}, addrs)
}
// TestGetNodeAddresses verifies that proper results are returned
// when requesting node addresses.
func TestGetNodeAddresses(t *testing.T) {
master, etcdserver, _, assert := setUp(t)
defer etcdserver.Terminate(t)
// Fail case (no addresses associated with nodes)
nodes, _ := master.nodeRegistry.ListNodes(api.NewDefaultContext(), nil)
addrs, err := master.getNodeAddresses()
assert.Error(err, "getNodeAddresses should have caused an error as there are no addresses.")
assert.Equal([]string(nil), addrs)
// Pass case with External type IP
nodes, _ = master.nodeRegistry.ListNodes(api.NewDefaultContext(), nil)
for index := range nodes.Items {
nodes.Items[index].Status.Addresses = []api.NodeAddress{{Type: api.NodeExternalIP, Address: "127.0.0.1"}}
}
addrs, err = master.getNodeAddresses()
assert.NoError(err, "getNodeAddresses should not have returned an error.")
assert.Equal([]string{"127.0.0.1", "127.0.0.1"}, addrs)
// Pass case with LegacyHost type IP
nodes, _ = master.nodeRegistry.ListNodes(api.NewDefaultContext(), nil)
for index := range nodes.Items {
nodes.Items[index].Status.Addresses = []api.NodeAddress{{Type: api.NodeLegacyHostIP, Address: "127.0.0.2"}}
}
addrs, err = master.getNodeAddresses()
assert.NoError(err, "getNodeAddresses failback should not have returned an error.")
assert.Equal([]string{"127.0.0.2", "127.0.0.2"}, addrs)
}
func (suite *OauthTestSuite) TestRefreshTokenGrantScopeCannotBeGreater() {
// Insert a test refresh token
err := suite.db.Create(&oauth.RefreshToken{
Token: "test_token",
ExpiresAt: time.Now().UTC().Add(+10 * time.Second),
Client: suite.clients[0],
User: suite.users[0],
Scope: "read_write",
}).Error
assert.NoError(suite.T(), err, "Inserting test data failed")
// Prepare a request
r, err := http.NewRequest("POST", "http://1.2.3.4/v1/oauth/tokens", nil)
assert.NoError(suite.T(), err, "Request setup should not get an error")
r.SetBasicAuth("test_client_1", "test_secret")
r.PostForm = url.Values{
"grant_type": {"refresh_token"},
"refresh_token": {"test_token"},
"scope": {"read read_write"},
}
// Serve the request
w := httptest.NewRecorder()
suite.router.ServeHTTP(w, r)
// Check the response
testutil.TestResponseForError(
suite.T(),
w,
oauth.ErrRequestedScopeCannotBeGreater.Error(),
400,
)
}
func TestParseValidateAndSignCSR(t *testing.T) {
tempBaseDir, err := ioutil.TempDir("", "swarm-ca-test-")
assert.NoError(t, err)
defer os.RemoveAll(tempBaseDir)
paths := ca.NewConfigPaths(tempBaseDir)
rootCA, err := ca.CreateAndWriteRootCA("rootCN", paths.RootCA)
assert.NoError(t, err)
csr, _, err := ca.GenerateAndWriteNewKey(paths.Node)
assert.NoError(t, err)
signedCert, err := rootCA.ParseValidateAndSignCSR(csr, "CN", "OU", "ORG")
assert.NoError(t, err)
assert.NotNil(t, signedCert)
parsedCert, err := helpers.ParseCertificatesPEM(signedCert)
assert.NoError(t, err)
assert.Equal(t, 2, len(parsedCert))
assert.Equal(t, "CN", parsedCert[0].Subject.CommonName)
assert.Equal(t, 1, len(parsedCert[0].Subject.OrganizationalUnit))
assert.Equal(t, "OU", parsedCert[0].Subject.OrganizationalUnit[0])
assert.Equal(t, 3, len(parsedCert[0].Subject.Names))
assert.Equal(t, "ORG", parsedCert[0].Subject.Organization[0])
assert.Equal(t, "rootCN", parsedCert[1].Subject.CommonName)
}
func TestTypeResolver_AnonymousStructs(t *testing.T) {
_, resolver, err := basicTaskListResolver(t)
if assert.NoError(t, err) {
// anonymous structs should be accounted for
parent := new(spec.Schema)
parent.Typed("object", "")
parent.Properties = make(map[string]spec.Schema)
parent.Properties["name"] = *spec.StringProperty()
parent.Properties["age"] = *spec.Int32Property()
rt, err := resolver.ResolveSchema(parent, true)
if assert.NoError(t, err) {
assert.False(t, rt.IsNullable)
assert.True(t, rt.IsAnonymous)
assert.True(t, rt.IsComplexObject)
}
parent.Extensions = make(spec.Extensions)
parent.Extensions["x-isnullable"] = true
rt, err = resolver.ResolveSchema(parent, true)
if assert.NoError(t, err) {
assert.True(t, rt.IsNullable)
assert.True(t, rt.IsAnonymous)
assert.True(t, rt.IsComplexObject)
}
}
}
func TestGetRemoteSignedCertificate(t *testing.T) {
tc := testutils.NewTestCA(t)
defer tc.Stop()
// Create a new CSR to be signed
csr, _, err := ca.GenerateAndWriteNewKey(tc.Paths.Node)
assert.NoError(t, err)
certs, err := ca.GetRemoteSignedCertificate(context.Background(), csr, tc.ManagerToken, tc.RootCA.Pool, tc.Remotes, nil, nil)
assert.NoError(t, err)
assert.NotNil(t, certs)
// Test the expiration for a manager certificate
parsedCerts, err := helpers.ParseCertificatesPEM(certs)
assert.NoError(t, err)
assert.Len(t, parsedCerts, 2)
assert.True(t, time.Now().Add(ca.DefaultNodeCertExpiration).AddDate(0, 0, -1).Before(parsedCerts[0].NotAfter))
assert.True(t, time.Now().Add(ca.DefaultNodeCertExpiration).AddDate(0, 0, 1).After(parsedCerts[0].NotAfter))
assert.Equal(t, parsedCerts[0].Subject.OrganizationalUnit[0], ca.ManagerRole)
// Test the expiration for an agent certificate
certs, err = ca.GetRemoteSignedCertificate(tc.Context, csr, tc.WorkerToken, tc.RootCA.Pool, tc.Remotes, nil, nil)
assert.NoError(t, err)
assert.NotNil(t, certs)
parsedCerts, err = helpers.ParseCertificatesPEM(certs)
assert.NoError(t, err)
assert.Len(t, parsedCerts, 2)
assert.True(t, time.Now().Add(ca.DefaultNodeCertExpiration).AddDate(0, 0, -1).Before(parsedCerts[0].NotAfter))
assert.True(t, time.Now().Add(ca.DefaultNodeCertExpiration).AddDate(0, 0, 1).After(parsedCerts[0].NotAfter))
assert.Equal(t, parsedCerts[0].Subject.OrganizationalUnit[0], ca.AgentRole)
}
func TestGetActiveSession(t *testing.T) {
kv := makeConsulClient(t)
consul := kv.(*Consul)
key := "foo"
value := []byte("bar")
// Put the first key with the Ephemeral flag
err := kv.Put(key, value, &store.WriteOptions{TTL: 2 * time.Second})
assert.NoError(t, err)
// Session should not be empty
session, err := consul.getActiveSession(key)
assert.NoError(t, err)
assert.NotEqual(t, session, "")
// Delete the key
err = kv.Delete(key)
assert.NoError(t, err)
// Check the session again, it should return nothing
session, err = consul.getActiveSession(key)
assert.NoError(t, err)
assert.Equal(t, session, "")
}
func TestGetRemoteSignedCertificateWithPending(t *testing.T) {
tc := testutils.NewTestCA(t)
defer tc.Stop()
// Create a new CSR to be signed
csr, _, err := ca.GenerateAndWriteNewKey(tc.Paths.Node)
assert.NoError(t, err)
updates, cancel := state.Watch(tc.MemoryStore.WatchQueue(), state.EventCreateNode{})
defer cancel()
completed := make(chan error)
go func() {
_, err := ca.GetRemoteSignedCertificate(context.Background(), csr, tc.WorkerToken, tc.RootCA.Pool, tc.Remotes, nil, nil)
completed <- err
}()
event := <-updates
node := event.(state.EventCreateNode).Node.Copy()
// Directly update the status of the store
err = tc.MemoryStore.Update(func(tx store.Tx) error {
node.Certificate.Status.State = api.IssuanceStateIssued
return store.UpdateNode(tx, node)
})
assert.NoError(t, err)
// Make sure GetRemoteSignedCertificate didn't return an error
assert.NoError(t, <-completed)
}
func testAtomicPutCreate(t *testing.T, kv store.Store) {
// Use a key in a new directory to ensure Stores will create directories
// that don't yet exist.
key := "testAtomicPutCreate/create"
value := []byte("putcreate")
// AtomicPut the key, previous = nil indicates create.
success, _, err := kv.AtomicPut(key, value, nil, nil)
assert.NoError(t, err)
assert.True(t, success)
// Get should return the value and an incremented index
pair, err := kv.Get(key)
assert.NoError(t, err)
if assert.NotNil(t, pair) {
assert.NotNil(t, pair.Value)
}
assert.Equal(t, pair.Value, value)
// Attempting to create again should fail.
success, _, err = kv.AtomicPut(key, value, nil, nil)
assert.Error(t, err)
assert.False(t, success)
// This CAS should succeed, since it has the value from Get()
success, _, err = kv.AtomicPut(key, []byte("PUTCREATE"), pair, nil)
assert.NoError(t, err)
assert.True(t, success)
}
// Test SessionLogout
func TestSessionLogout(t *testing.T) {
var (
//d *OVTest
c *ICSPClient
//testSerial string
)
if os.Getenv("ONEVIEW_TEST_ACCEPTANCE") == "true" {
_, c = getTestDriverA()
if c == nil {
t.Fatalf("Failed to execute getTestDriver() ")
}
//data, err := c.SessionLogin()
// this is needed so we can "copy" the session id to the ov client
err := c.RefreshLogin()
//log.Debugf(" login key -> %s, session data -> %+v", c.APIKey, data)
log.Debugf(" login key -> %s", c.APIKey)
assert.NoError(t, err, "SessionLogin threw error -> %s", err)
//assert.NotEmpty(t, data.ID, fmt.Sprintf("SessionLogin is empty! something went wrong, err -> %s, data -> %+v\n", err, data))
//assert.Equal(t, "none", c.APIKey)
err = c.SessionLogout()
log.Debugf(" login key after logout -> %s", c.APIKey)
assert.NoError(t, err, "SessionLogout threw error -> %s", err)
// test if we can perform an op after logout
//_, err = c.GetProfileBySN(testSerial)
//assert.Error(t, err, "SessionLogin threw error -> %s", err)
} else {
/*_, c = getTestDriverU()
data, err := c.SessionLogin()
assert.Error(t,err, fmt.Sprintf("ALL ok, no error, caught as expected: %s,%+v\n",err, data))
assert.Equal(t, "none", c.APIKey)
*/
}
}