Esempio n. 1
0
// Verify if the items being read are as expected.
func CheckOpsReader(t *testing.T, loader OpsReader) {
	expectedOpsRead := 0
	const startingTs = 1396456709420
	for op := loader.Next(); op != nil; op = loader.Next() {
		expectedOpsRead += 1
		ensure.NotNil(t, op)
		ensure.DeepEqual(t, loader.OpsRead(), expectedOpsRead)

		// check the "ts" field
		CheckTime(t, float64(startingTs+loader.OpsRead()), op.Timestamp)

		// check the insert doc
		// certain key exists
		for i := 1; i <= 5; i++ {
			logTypeKey := fmt.Sprintf("logType%d", i)
			logType, ok := GetElem(op.InsertDoc, logTypeKey)
			if i != expectedOpsRead {
				ensure.False(t, ok)
				ensure.Nil(t, logType)
			} else {
				ensure.True(t, ok)
				ensure.NotNil(t, logType)
			}
		}
		// check the value for the shared key
		message := fmt.Sprintf("m%d", expectedOpsRead)
		actualMessage, ok := GetElem(op.InsertDoc, "message")
		ensure.True(t, ok)
		ensure.DeepEqual(t, actualMessage.(string), message)
	}
	ensure.DeepEqual(t, expectedOpsRead, 5)
}
func TestUploadFiles(t *testing.T) {
	t.Parallel()
	h := parsecli.NewHarness(t)
	defer h.Stop()

	h.MakeEmptyRoot()
	createRandomFiles(t, h)

	names := []string{"a", "b"}
	ht := parsecli.TransportFunc(func(r *http.Request) (*http.Response, error) {
		switch filepath.Base(r.URL.Path) {
		case names[0]:
			ensure.NotNil(t, r.Header)
			ensure.DeepEqual(t, r.Header.Get("Key"), "Value")
			ensure.DeepEqual(t, r.Header.Get("Content-Type"), "application/octet-stream")
			ensure.DeepEqual(t, r.Header.Get("Content-MD5"), "4JnleFGzGppuArF6N50EWg==")
			return &http.Response{
				StatusCode: http.StatusOK,
				Body:       ioutil.NopCloser(strings.NewReader(`{"status":"success"}`)),
			}, nil
		case names[1]:
			ensure.NotNil(t, r.Header)
			ensure.DeepEqual(t, r.Header.Get("Key"), "Value")
			ensure.DeepEqual(t, r.Header.Get("Content-Type"), "application/octet-stream")
			ensure.DeepEqual(t, r.Header.Get("Content-MD5"), "Fv43qsp6mnGCJlC00VkOcA==")
			return &http.Response{
				StatusCode: http.StatusOK,
				Body:       ioutil.NopCloser(strings.NewReader(`{"status":"success"}`)),
			}, nil
		default:
			return &http.Response{
				StatusCode: http.StatusInternalServerError,
				Body:       ioutil.NopCloser(strings.NewReader(`{"error":"something is wrong"}`)),
			}, nil
		}
	})
	h.Env.ParseAPIClient = &parsecli.ParseAPIClient{APIClient: &parse.Client{Transport: ht}}

	var filenames []string
	for _, name := range names {
		filenames = append(filenames, filepath.Join(h.Env.Root, name))
	}
	ensure.Nil(t, uploadSymbolFiles(filenames[:],
		map[string]string{"Key": "Value"}, true, h.Env))
	for _, filename := range filenames {
		_, err := os.Lstat(filename)
		ensure.NotNil(t, err)
		ensure.True(t, os.IsNotExist(err))
	}
}
Esempio n. 3
0
func TestServerAbort(t *testing.T) {
	t.Parallel()
	for _, code := range []int{200, 500} {
		server := httptest.NewServer(
			http.HandlerFunc(
				func(w http.ResponseWriter, r *http.Request) {
					w.Header().Add("Content-Length", "4000")
					w.WriteHeader(code)
					w.Write(bytes.Repeat([]byte("a"), 3000))
				},
			),
		)

		u, err := url.Parse(server.URL)
		ensure.Nil(t, err)

		c := &parse.Client{
			Credentials: defaultRestAPIKey,
			BaseURL:     u,
		}
		res := make(map[string]interface{})
		_, err = c.Get(nil, res)
		ensure.NotNil(t, err)
		server.CloseClientConnections()
		server.Close()
	}
}
Esempio n. 4
0
func TestProvideWithFields(t *testing.T) {
	var g inject.Graph
	a := &TypeAnswerStruct{}
	err := g.Provide(&inject.Object{Value: a, Fields: map[string]*inject.Object{}})
	ensure.NotNil(t, err)
	ensure.DeepEqual(t, err.Error(), "fields were specified on object *inject_test.TypeAnswerStruct when it was provided")
}
Esempio n. 5
0
func TestServerAbort(t *testing.T) {
	t.Parallel()
	for _, code := range []int{200, 500} {
		server := httptest.NewServer(
			http.HandlerFunc(
				func(w http.ResponseWriter, r *http.Request) {
					w.Header().Add("Content-Length", "4000")
					w.WriteHeader(code)
					w.Write(bytes.Repeat([]byte("a"), 3000))
				},
			),
		)

		u, err := url.Parse(server.URL)
		ensure.Nil(t, err)

		c := &fbapi.Client{
			BaseURL: u,
		}
		_, err = c.Do(&http.Request{Method: "GET"}, nil)
		ensure.NotNil(t, err)
		ensure.Err(t, err, regexp.MustCompile("(invalid character|EOF)"))
		server.CloseClientConnections()
		server.Close()
	}
}
Esempio n. 6
0
func TestPrintListNoConfig(t *testing.T) {
	t.Parallel()
	h, l := newListCmdHarness(t)
	h.makeEmptyRoot()
	defer h.Stop()
	ensure.NotNil(t, l.printListOfApps(h.env))
	ensure.DeepEqual(t, h.Out.String(), "")
}
Esempio n. 7
0
func TestMissingCredentials(t *testing.T) {
	t.Parallel()
	var c parse.Client
	req := http.Request{Method: "GET", URL: &url.URL{Path: "classes/Foo/Bar"}}
	_, err := c.Do(&req, nil, nil)
	ensure.NotNil(t, err)
	ensure.Err(t, err, regexp.MustCompile(`parse: api error with message="unauthorized"`))
}
Esempio n. 8
0
func TestInheritErrorOnListenUnixWithInvalidCount(t *testing.T) {
	var n Net
	os.Setenv(envCountKey, "a")
	tmpdir, err := ioutil.TempDir("", "TestInheritErrorOnListenUnixWithInvalidCount-")
	ensure.Nil(t, err)
	ensure.Nil(t, os.RemoveAll(tmpdir))
	_, err = n.Listen("unix", filepath.Join(tmpdir, "socket"))
	ensure.NotNil(t, err)
}
func TestBase64MD5OfFileNoFile(t *testing.T) {
	t.Parallel()
	h := parsecli.NewHarness(t)
	defer h.Stop()

	h.MakeEmptyRoot()
	testFile := filepath.Join(h.Env.Root, "test")
	_, err := base64MD5OfFile(testFile)
	ensure.NotNil(t, err)
}
Esempio n. 10
0
func TestReleasesCmdError(t *testing.T) {
	h, c := newReleasesCmdHarness(t)
	defer h.Stop()
	ht := parsecli.TransportFunc(func(r *http.Request) (*http.Response, error) {
		return nil, stackerr.New("Throws error")
	})
	h.Env.ParseAPIClient = &parsecli.ParseAPIClient{APIClient: &parse.Client{Transport: ht}}

	ensure.NotNil(t, c.run(h.Env, &parsecli.Context{}))
}
Esempio n. 11
0
func TestNewConfig(t *testing.T) {
	var err error

	// CASE 1: unmarshalling err
	_, err = newConfig(strings.NewReader("?????"))
	ensure.NotNil(t, err)

	// CASE 2: success!
	_, err = newConfig(strings.NewReader(""))
	ensure.Nil(t, err)
}
Esempio n. 12
0
// Start starts server used for MockS3
func (s *MockS3) Start(t *testing.T) {
	srv, err := s3test.NewServer(s.config)
	ensure.Nil(t, err)
	ensure.NotNil(t, srv)

	s.srv = srv
	s.region = aws.Region{
		Name:                 "faux-region-1",
		S3Endpoint:           srv.URL(),
		S3LocationConstraint: true, // s3test server requires a LocationConstraint
	}
}
Esempio n. 13
0
func CheckSetStartTime(t *testing.T, loader OpsReader) {
	expectedOpsRead := 0
	numSkipped, err := loader.SetStartTime(1396456709424)
	ensure.Nil(t, err)
	ensure.DeepEqual(t, numSkipped, int64(4))

	for op := loader.Next(); op != nil; op = loader.Next() {
		expectedOpsRead += 1
		ensure.NotNil(t, op)
		ensure.DeepEqual(t, loader.OpsRead(), expectedOpsRead)
	}

	// Verify that only 4 ops are read, since we skipped one
	ensure.DeepEqual(t, expectedOpsRead, 1)
}
Esempio n. 14
0
func CheckSkipOps(t *testing.T, loader OpsReader) {
	expectedOpsRead := 0

	// Skip a single op
	loader.SkipOps(1)

	// Read all remaining ops
	for op := loader.Next(); op != nil; op = loader.Next() {
		expectedOpsRead += 1
		ensure.NotNil(t, op)
		ensure.DeepEqual(t, loader.OpsRead(), expectedOpsRead)
	}

	// Verify that only 4 ops are read, since we skipped one
	ensure.DeepEqual(t, expectedOpsRead, 4)
}
Esempio n. 15
0
func TestSafeGetInt(t *testing.T) {
	val, err := safeGetInt(int32(11))
	ensure.Nil(t, err)
	ensure.DeepEqual(t, val, int(11))
	val, err = safeGetInt(int64(11))
	ensure.Nil(t, err)
	ensure.DeepEqual(t, val, int(11))
	val, err = safeGetInt(float32(11))
	ensure.Nil(t, err)
	ensure.DeepEqual(t, val, int(11))
	val, err = safeGetInt(float64(11))
	ensure.Nil(t, err)
	ensure.DeepEqual(t, val, int(11))
	val, err = safeGetInt("a")
	ensure.NotNil(t, err)
}
Esempio n. 16
0
func TestRunWithAppNamed(t *testing.T) {
	t.Parallel()
	h := newHarness(t)
	defer h.Stop()
	const appName = "a"
	c := &parseConfig{
		Applications: map[string]*parseAppConfig{
			appName: {ApplicationID: "id", MasterKey: "token"},
		},
	}
	h.makeWithConfig(jsonStr(t, c))
	r := runWithClient(h.env, func(e *env, c *context) error {
		ensure.NotNil(t, c)
		return nil
	})
	r(noOpCmd(), []string{"a"})
}
Esempio n. 17
0
func TestRunWithDefault(t *testing.T) {
	t.Parallel()
	h := NewHarness(t)
	defer h.Stop()
	const appName = "a"
	c := &ParseConfig{
		Applications: map[string]*ParseAppConfig{
			appName:    {ApplicationID: "id", MasterKey: "token"},
			DefaultKey: {Link: appName},
		},
	}
	h.MakeWithConfig(jsonStr(t, c))
	r := RunWithClient(h.Env, func(e *Env, c *Context) error {
		ensure.NotNil(t, c)
		return nil
	})
	r(noOpCmd(), []string{"a"})
}
func TestParseVersionFromBytes(t *testing.T) {
	t.Parallel()

	_, err := parseVersionFromBytes([]byte(`versionCode='a'`))
	ensure.NotNil(t, err)

	tests := []struct {
		input    string
		expected int
	}{
		{`versionCode='1'`, 1},
		{`versionCode='12'`, 12},
		{`versionCode='1234'`, 1234},
		{`versionCode='12345678'`, 12345678},
	}

	for _, test := range tests {
		actual, err := parseVersionFromBytes([]byte(test.input))
		ensure.Nil(t, err)
		ensure.DeepEqual(t, actual, test.expected)
	}
}
Esempio n. 19
0
func TestRunWithAppError(t *testing.T) {
	t.Parallel()
	h := newHarness(t)
	defer h.Stop()
	const appName = "a"
	c := &parseConfig{
		Applications: map[string]*parseAppConfig{
			appName: {ApplicationID: "id", MasterKey: "token"},
		},
	}
	h.makeWithConfig(jsonStr(t, c))
	h.env.Exit = func(i int) { panic(exitCode(i)) }
	const message = "hello world"
	func() {
		defer ensure.PanicDeepEqual(t, exitCode(1))
		r := runWithClient(h.env, func(e *env, c *context) error {
			ensure.NotNil(t, c)
			return errors.New(message)
		})
		r(noOpCmd(), []string{"a"})
	}()
	ensure.StringContains(t, h.Err.String(), message)
}
Esempio n. 20
0
// inserting data voilating index clause on a separate connection should fail
func TestEnsureIndex(t *testing.T) {
	t.Parallel()
	p := NewSingleHarness(t)
	defer p.Stop()
	session := p.ProxySession()
	collection := session.DB("test").C("coll1")
	index := mgo.Index{
		Key:        []string{"lastname", "firstname"},
		Unique:     true,
		DropDups:   true,
		Background: true, // See notes.
		Sparse:     true,
	}
	err := collection.EnsureIndex(index)
	ensure.Nil(t, err)
	err = collection.Insert(
		map[string]string{
			"firstname": "harvey",
			"lastname":  "dent",
		},
	)
	if err != nil {
		t.Fatal("insertion error", err)
	}
	session.Close()
	session = p.ProxySession()
	defer session.Close()
	collection = session.DB("test").C("coll1")
	err = collection.Insert(
		map[string]string{
			"firstname": "harvey",
			"lastname":  "dent",
		},
	)
	ensure.NotNil(t, err)
}
Esempio n. 21
0
// inserting data voilating index clause on a separate connection should fail
func TestEnsureIndex(t *testing.T) {
	withHarness(t, func(harness *ReplicaSetHarness) {
		session := harness.ProxySession()
		collection := session.DB("test").C("testensureindex")
		collection.DropIndex("lastname", "firstname")
		index := mgo.Index{
			Key:        []string{"lastname", "firstname"},
			Unique:     true,
			DropDups:   true,
			Background: true, // See notes.
			Sparse:     true,
		}
		err := collection.EnsureIndex(index)
		ensure.Nil(t, err)
		err = collection.Insert(
			map[string]string{
				"firstname": "harvey",
				"lastname":  "dent",
			},
		)
		if err != nil {
			t.Fatal("insertion error", err)
		}
		session.Close()
		session = harness.ProxySession()
		defer session.Close()
		collection = session.DB("test").C("testensureindex")
		err = collection.Insert(
			map[string]string{
				"firstname": "harvey",
				"lastname":  "dent",
			},
		)
		ensure.NotNil(t, err)
	})
}
Esempio n. 22
0
func TestNewBlank(t *testing.T) {
	b, err := blank.NewBlank("", false, "")
	ensure.NotNil(t, b)
	ensure.Nil(t, err)
}
Esempio n. 23
0
func TestInheritErrorOnListenTCPWithInvalidCount(t *testing.T) {
	var n Net
	os.Setenv(envCountKey, "a")
	_, err := n.Listen("tcp", ":0")
	ensure.NotNil(t, err)
}
Esempio n. 24
0
func TestNonNil(t *testing.T) {
	var c capture
	ensure.NotNil(&c, nil)
	c.Equal(t, `ensure_test.go:136: expected a value but got nil`)
}
Esempio n. 25
0
func TestExecution(t *testing.T) {
	test_db := "test_db_for_executor"
	test_collection := "c1"

	session, err := mgo.Dial("localhost")
	ensure.Nil(t, err)
	ensure.NotNil(t, session)
	defer session.Close()

	err = session.DB(test_db).DropDatabase()
	ensure.Nil(t, err)

	testNs := fmt.Sprintf("%s.%s", test_db, test_collection)

	// insertion
	insertOp := &Op{
		Ns:        testNs,
		Timestamp: time.Unix(1396456709, int64(427*time.Millisecond)),
		InsertDoc: bson.D{
			{"logType", "console"},
			{"message", "start"},
			{"_id", bson.ObjectIdHex("533c3d03c23fffd217678ee8")},
			{"timestamp", bson.D{{"$date", 1396456707977}}},
		},
		Type: Insert,
	}
	normalizeOp(insertOp)
	logger, err := NewLogger("", "")
	ensure.Nil(t, err)
	exec := NewOpsExecutor(session, nil, logger)
	err = exec.Execute(insertOp)
	ensure.Nil(t, err)
	coll := session.DB(test_db).C(test_collection)
	count, err := coll.Count()
	ensure.DeepEqual(t, count, 1)

	// Find
	findOp := &Op{
		Ns:        testNs,
		Timestamp: time.Unix(1396456709, int64(472*time.Millisecond)),
		QueryDoc: bson.D{
			{
				"$query", bson.D{
					{"$or", []bson.D{bson.D{{"_id", bson.ObjectIdHex("533c3d03c23fffd217678ee8")}}}},
				},
			},
			{"$maxScan", 9000000},
		},
		Type:      Query,
		NToReturn: 1,
		NToSkip:   0,
	}
	normalizeOp(findOp)
	err = exec.Execute(findOp)
	ensure.Nil(t, err)

	findResult := exec.lastResult.(*[]Document)
	ensure.DeepEqual(t, len(*findResult), 1)
	exec.lastResult = nil

	// Update
	updateOp := &Op{
		Ns:        testNs,
		Timestamp: time.Unix(1396456709, int64(472*time.Millisecond)),
		QueryDoc: bson.D{
			{"_id", bson.ObjectIdHex("533c3d03c23fffd217678ee8")},
		},
		UpdateDoc: bson.D{
			{"$set", bson.D{{"logType", "hooo"}}},
		},
		Type: Update,
	}

	normalizeOp(updateOp)
	err = exec.Execute(updateOp)
	ensure.Nil(t, err)

	// Check that the document is updated
	normalizeOp(findOp)
	err = exec.Execute(findOp)
	ensure.Nil(t, err)
	findResult = exec.lastResult.(*[]Document)
	ensure.DeepEqual(t, (*findResult)[0]["logType"].(string), "hooo")
	findResult = nil

	// findAndModify
	famOp := &Op{
		Ns:        fmt.Sprintf("%s.$cmd", test_db),
		Timestamp: time.Unix(1396456709, int64(472*time.Millisecond)),
		CommandDoc: bson.D{
			{"findandmodify", test_collection},
			{"query", bson.D{{"_id", bson.ObjectIdHex("533c3d03c23fffd217678ee8")}}},
			{"update", bson.D{{"$set", bson.D{{"logType", "foobar"}}}}},
		},
		Type: Command,
	}
	normalizeOp(famOp)
	err = exec.Execute(famOp)
	ensure.Nil(t, err)

	// check that the doc is modified
	normalizeOp(findOp)
	err = exec.Execute(findOp)
	ensure.Nil(t, err)
	findResult = exec.lastResult.(*[]Document)
	ensure.DeepEqual(t, (*findResult)[0]["logType"].(string), "foobar")
	findResult = nil

	// Remove
	removeOp := &Op{
		Ns:        testNs,
		Timestamp: time.Unix(1396456709, int64(432*time.Millisecond)),
		QueryDoc:  bson.D{{"_id", bson.ObjectIdHex("533c3d03c23fffd217678ee8")}},
		Type:      Remove,
	}
	normalizeOp(removeOp)
	err = exec.Execute(removeOp)
	ensure.Nil(t, err)

	// check that the doc is gone
	normalizeOp(findOp)
	err = exec.Execute(findOp)
	ensure.Nil(t, err)
	findResult = exec.lastResult.(*[]Document)
	ensure.DeepEqual(t, len(*findResult), 0)
}
Esempio n. 26
0
func TestErrorCases(t *testing.T) {
	cases := []struct {
		Request    *http.Request
		Body       interface{}
		Error      string
		StatusCode int
		Transport  http.RoundTripper
	}{
		{
			Request: &http.Request{
				Method: "GET",
				URL: &url.URL{
					Scheme: "https",
					Host:   "api.parse.com",
					Path:   "/1/classes/Foo/Bar",
				},
			},
			Error:      `parse: api error with code=101 and message="object not found for get"`,
			StatusCode: http.StatusNotFound,
			Transport: transportFunc(func(r *http.Request) (*http.Response, error) {
				j := jsonB(t, parse.Error{
					Code:    101,
					Message: "object not found for get",
				})
				return &http.Response{
					StatusCode: http.StatusNotFound,
					Status:     "404 Not Found",
					Body:       ioutil.NopCloser(bytes.NewReader(j)),
				}, nil
			}),
		},
		{
			Request: &http.Request{
				Method: "GET",
				URL: &url.URL{
					Scheme: "https",
					Host:   "api.parse.com",
					Path:   "/1/classes/Foo/Bar",
				},
			},
			Body:  map[int]int{},
			Error: "unsupported type: map[int]int",
			Transport: transportFunc(func(r *http.Request) (*http.Response, error) {
				panic("not reached")
			}),
		},
		{
			Request: &http.Request{
				Method: "GET",
				URL:    &url.URL{Path: "/"},
			},
			Error:      `error with status=404 and body="<html>`,
			StatusCode: 404,
			Transport: transportFunc(func(r *http.Request) (*http.Response, error) {
				return &http.Response{
					StatusCode: http.StatusNotFound,
					Status:     "404 Not Found",
					Body:       ioutil.NopCloser(strings.NewReader("<html>")),
				}, nil
			}),
		},
	}

	t.Parallel()
	for _, ec := range cases {
		c := &parse.Client{
			Credentials: defaultRestAPIKey,
		}
		if !realTransport {
			c.Transport = ec.Transport
		}
		res, err := c.Do(ec.Request, ec.Body, nil)
		ensure.NotNil(t, err)
		ensure.StringContains(t, err.Error(), ec.Error, ec)
		if ec.StatusCode != 0 {
			ensure.False(t, res == nil, ec)
			ensure.DeepEqual(t, res.StatusCode, ec.StatusCode, ec)
		}
	}
}