Example #1
0
func TestImportTaskWithSuccess(t *testing.T) {
	httpmock.Activate()
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterNoResponder(httpmock.NewStringResponder(200, `{"meta":{"status":200},"data":{"id":176,"file":{"name":"string.po","format":"GNU_PO","locale":{"code":"en-US","english_name":"English (United States)","local_name":"English (United States)","locale":"en","region":"US"}},"string_count":236,"word_count":1260,"status":"in-progress","created_at":"2013-10-07T15:27:10+0000","created_at_timestamp":1381159630}}`))
	client := Client{APIKey: "abcdef", Secret: "abcdef", ProjectID: 1}

	res, err := client.ImportTask(1)
	assert.Nil(t, err)

	assert.Equal(t,
		TaskData{
			ID:         176,
			OriginalID: float64(176),
			File: TaskFile{
				Name:   "string.po",
				Format: "GNU_PO",
				Locale: Language{
					Code:        "en-US",
					EnglishName: "English (United States)",
					LocalName:   "English (United States)",
					Locale:      "en",
					Region:      "US",
				},
			},
			StringCount:         236,
			WordCount:           1260,
			Status:              "in-progress",
			CreateddAt:          "2013-10-07T15:27:10+0000",
			CreateddAtTimestamp: 1381159630,
		}, res)
}
func TestMemPlugin(t *testing.T) {
	Convey("getMemstat Should return memory amount value", t, func() {

		httpmock.Activate()
		defer httpmock.DeactivateAndReset()
		httpmock.RegisterResponder("GET", "http://192.168.192.200:8000/os/memory/free",
			func(req *http.Request) (*http.Response, error) {
				resp := httpmock.NewStringResponse(200, "20000")
				return resp, nil

			},
		)
		httpmock.RegisterResponder("GET", "http://192.168.192.200:8000/os/memory/total",
			func(req *http.Request) (*http.Response, error) {
				resp := httpmock.NewStringResponse(200, "10000")
				return resp, nil

			},
		)

		memFree, err := getMemStat("http://192.168.192.200:8000", "free")
		So(err, ShouldBeNil)
		So(strconv.FormatUint(memFree, 10), ShouldResemble, "20000")
		memTotal, err := getMemStat("http://192.168.192.200:8000", "total")
		So(err, ShouldBeNil)
		So(strconv.FormatUint(memTotal, 10), ShouldResemble, "10000")

	})
	Convey("MemStat Should return pluginMetricType Data", t, func() {

		httpmock.Activate()
		defer httpmock.DeactivateAndReset()
		httpmock.RegisterResponder("GET", "http://192.168.192.200:8000/os/memory/free",
			func(req *http.Request) (*http.Response, error) {
				resp := httpmock.NewStringResponse(200, "20000")
				return resp, nil

			},
		)
		httpmock.RegisterResponder("GET", "http://192.168.192.200:8000/os/memory/total",
			func(req *http.Request) (*http.Response, error) {
				resp := httpmock.NewStringResponse(200, "10000")
				return resp, nil

			},
		)

		ns := []string{"osv", "memory", "free"}
		ns2 := []string{"osv", "memory", "total"}
		memFree, err := memStat(ns, "http://192.168.192.200:8000")
		So(err, ShouldBeNil)
		So(memFree.Namespace_, ShouldResemble, ns)
		So(memFree.Data_, ShouldResemble, "20000")
		memTotal, err := memStat(ns2, "http://192.168.192.200:8000")
		So(err, ShouldBeNil)
		So(memTotal.Namespace_, ShouldResemble, ns2)
		So(memTotal.Data_, ShouldResemble, "10000")

	})
}
Example #3
0
func TestUploadFileWithSuccess(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterNoResponder(httpmock.NewStringResponder(201, `{"meta":{"status":201},"data":{"name":"string.po","format":"GNU_PO","language":{"code":"en-US","english_name":"English (United States)","local_name":"English (United States)","locale":"en","region":"US"},"import":{"id":154,"created_at":"2013-10-07T15:27:10+0000","created_at_timestamp":1381159630}}}`))
	client := Client{APIKey: "abcdef", Secret: "abcdef", ProjectID: 1}

	tmpdir, err := ioutil.TempDir("", "")
	assert.Nil(t, err)
	defer os.RemoveAll(tmpdir)

	filename := path.Join(tmpdir, "string.po")
	ioutil.WriteFile(filename, []byte("test"), 0666)

	res, err := client.UploadFile(filename, "GNU_PO", "en_US", true)
	assert.Nil(t, err)

	assert.Equal(t, UploadData{
		Name:   "string.po",
		Format: "GNU_PO",
		Language: Language{
			Code:        "en-US",
			EnglishName: "English (United States)",
			LocalName:   "English (United States)",
			Locale:      "en",
			Region:      "US",
		},
		Import: TaskData{
			ID:                  154,
			OriginalID:          154.0,
			CreateddAt:          "2013-10-07T15:27:10+0000",
			CreateddAtTimestamp: 1381159630,
		},
	}, res)
}
Example #4
0
func TestGetBookmarkCountError(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	res := "0"
	httpmock.RegisterResponder(
		"GET",
		"http://api.b.st-hatena.com/entry.count?url=http%3A%2F%2Fdeveloper.hatena.ne.jp",
		func(req *http.Request) (*http.Response, error) {
			return nil, errors.New("internal server error")
		},
	)

	input := "http://developer.hatena.ne.jp"
	expected, err := strconv.Atoi(res)

	count, err := GetBookmarkCount(input)
	if err == nil {
		t.Errorf("fail mock: %s\n", input)
	}

	if count != expected {
		t.Errorf("expected count %d, but got %d\n", expected, count)
	}
}
Example #5
0
func TestSegmentPager(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	mock.RegisterSegmentMocks()

	var (
		completed     bool
		countEntities int
	)

	client := NewLytics(mock.MockApiKey, nil, nil)

	// start the paging routine
	scan := client.PageSegmentId(mock.MockSegmentID1)
	assert.Equal(t, nil, scan.Err())

	// handle processing the entities
	for {
		e := scan.Next()
		if e == nil {
			completed = true
			break
		}
		countEntities++
		assert.Equal(t, e["email"], fmt.Sprintf("email%[email protected]", countEntities))
	}
	assert.Equal(t, countEntities, 13)
	assert.Equal(t, completed, true)
	t.Logf("*** COMPLETED SCAN: %d total entities", scan.Total)
}
Example #6
0
func TestGetBookmarkCounts(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	res := `
{
	"https://github.com":111,
	"https://bitbucket.org":222,
	"http://stackoverflow.com":333
}
`
	httpmock.RegisterResponder(
		"GET",
		"http://api.b.st-hatena.com/entry.counts?url=https%3A%2F%2Fgithub.com&url=https%3A%2F%2Fbitbucket.org&url=http%3A%2F%2Fstackoverflow.com",
		httpmock.NewStringResponder(200, res))

	input := []string{
		"https://github.com",
		"https://bitbucket.org",
		"http://stackoverflow.com",
	}
	expected := map[string]int{}
	json.Unmarshal([]byte(res), &expected)

	counts, err := GetBookmarkCounts(input)
	if err != nil {
		t.Errorf("fail mock: %#v\n", input)
	}

	for url, count := range counts {
		if count != expected[url] {
			t.Errorf("expected count %d, but got %d\n", expected[url], count)
		}
	}
}
Example #7
0
func TestImportTasksWithSuccess(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterNoResponder(httpmock.NewStringResponder(200, `{"meta":{"status":200},"data":[{"id":"177","file":{"name":"string2.po"},"status":"in-progress","created_at":"2013-10-07T15:25:00+0000","created_at_timestamp":1381159500},{"id":"176","file":{"name":"string.po"},"status":"in-progress","created_at":"2013-10-07T15:27:10+0000","created_at_timestamp":1381159630}]}`))
	client := Client{APIKey: "abcdef", Secret: "abcdef", ProjectID: 1}

	res, err := client.ImportTasks(map[string]interface{}{"page": 1, "per_page": 50, "status": "in-progress"})
	assert.Nil(t, err)

	assert.Equal(t,
		[]TaskData{
			TaskData{
				ID:         177,
				OriginalID: "177",
				File: TaskFile{
					Name: "string2.po",
				},
				Status:              "in-progress",
				CreateddAt:          "2013-10-07T15:25:00+0000",
				CreateddAtTimestamp: 1381159500,
			},
			TaskData{
				ID:         176,
				OriginalID: "176",
				File: TaskFile{
					Name: "string.po",
				},
				Status:              "in-progress",
				CreateddAt:          "2013-10-07T15:27:10+0000",
				CreateddAtTimestamp: 1381159630,
			},
		}, res)
}
Example #8
0
func TestGetOrders(t *testing.T) {

	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder("GET", TICTAIL_TEST_URL+"/v1/stores/x1234/orders",
		func(req *http.Request) (*http.Response, error) {
			if req.Header.Get("Authorization") == "Bearer "+TICTAIL_TEST_KEY {
				return httpmock.NewStringResponse(200, TICTAIL_MOCK_GET_ORDERS_200_RESPONSE), nil
			}
			return httpmock.NewStringResponse(401, "{}"), nil
		},
	)

	tt := NewTictail(TICTAIL_TEST_KEY)

	response, err := tt.GetAllOrders("x1234")
	if err != nil {
		t.Error(err.Error())
	}
	t.Logf("response: %#v", response)

	var expectedData []spec.OrdersResponse
	err = json.Unmarshal([]byte(TICTAIL_MOCK_GET_ORDERS_200_RESPONSE), &expectedData)
	if err != nil {
		t.Error(err.Error())
	}

	if !reflect.DeepEqual(expectedData, response) {
		t.Error("Response and mock data didn't match")
	}

}
Example #9
0
func TestGetSegmentSizes(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	mock.RegisterSegmentMocks()

	var segments []string

	client := NewLytics(mock.MockApiKey, nil, nil)

	segments = []string{
		mock.MockSegmentID1,
	}

	seg, err := client.GetSegmentSizes(segments)
	assert.Equal(t, err, nil)
	assert.T(t, seg[0].Id == segments[0])

	segments = []string{
		mock.MockSegmentID1,
		mock.MockSegmentID2,
	}

	// params
	seg, err = client.GetSegmentSizes(segments)
	assert.Equal(t, err, nil)
	assert.T(t, len(seg) == 2)
}
Example #10
0
func TestListTemplatesSortedByName(t *testing.T) {
	assert := assert.New(t)
	output := new(bytes.Buffer)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterResponder("GET", "https://api.github.com/repos/github/gitignore/contents/",
		httpmock.NewStringResponder(200, `[
  {
    "name": "C.gitignore"
  },
  {
    "name": "A.gitignore"
  }
]
`))
	httpmock.RegisterResponder("GET", "https://api.github.com/repos/github/gitignore/contents/Global",
		httpmock.NewStringResponder(200, `[
  {
    "name": "B.gitignore"
  }
]
`))

	app([]string{"chtignore", "list"}, output)

	assert.ThatString(output.String()).IsEqualTo(fmt.Sprintln("A, B, C, JetBrains-build"))
}
Example #11
0
func TestGetTranslationsStatusWithSuccess(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterNoResponder(httpmock.NewStringResponder(200, `{"meta":{"status":200},"data":{"file_name":"string.po","locale":{"code":"ja-JP","english_name":"Japanese","local_name":"\u65e5\u672c\u8a9e","locale":"ja","region":"JP"},"progress":"92%","string_count":1359,"word_count":3956}}`))
	client := Client{APIKey: "abcdef", Secret: "abcdef", ProjectID: 1}

	res, err := client.GetTranslationsStatus("string.po", "ja-JP")
	assert.Nil(t, err)

	assert.Equal(t,
		TranslationsStatus{
			FileName: "string.po",
			Locale: Language{
				Code:         "ja-JP",
				EnglishName:  "Japanese",
				LocalName:    "日本語",
				CustomLocale: "",
				Locale:       "ja",
				Region:       "JP",
			},
			Progress:    "92%",
			StringCount: 1359,
			WordCount:   3956,
		}, res)
}
Example #12
0
func TestGetFavoriteFeedError(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(
		"GET",
		"http://b.hatena.ne.jp/yukihir0/favorite.rss",
		func(req *http.Request) (*http.Response, error) {
			return nil, errors.New("internal server error")
		},
	)

	input := "yukihir0"
	params := NewFavoriteFeedParams(input)
	expected := FavoriteFeed{}

	feed, err := GetFavoriteFeed(params)
	if err == nil {
		t.Errorf("fail mock: %#v\n", input)
	}

	if !reflect.DeepEqual(feed, expected) {
		t.Errorf("expected favorite feed %#v, but got %#v\n", expected, feed)
	}
}
Example #13
0
func TestGetBookmarkCountsError(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	httpmock.RegisterResponder(
		"GET",
		"http://api.b.st-hatena.com/entry.counts?url=https%3A%2F%2Fgithub.com&url=https%3A%2F%2Fbitbucket.org&url=http%3A%2F%2Fstackoverflow.com",
		func(req *http.Request) (*http.Response, error) {
			return nil, errors.New("internal server error")
		},
	)

	input := []string{
		"https://github.com",
		"https://bitbucket.org",
		"http://stackoverflow.com",
	}
	expected := map[string]int{}

	counts, err := GetBookmarkCounts(input)
	if err == nil {
		t.Errorf("fail mock: %#v\n", input)
	}

	if !reflect.DeepEqual(counts, expected) {
		t.Errorf("expected counts %#v, but got %#v\n", expected, counts)
	}
}
Example #14
0
func TestPostsRecentHighCount(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	_, _, err := client.Posts.Recent(nil, 1000)
	if err.Error() != "count must be below 100" {
		t.Error(err)
	}
}
Example #15
0
func TestSendEcoSMSSuccess(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterResponder("POST", "https://api.smsapi.pl/sms.do", httpmock.NewStringResponder(200, `OK:1013211`))

	object := New("testuser", "testpasswd")
	err := object.SendEcoSMS("XXXXXXXXX", "test message")
	assert.NoError(t, err)
}
Example #16
0
func TestListFilesWithFailure(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterNoResponder(httpmock.NewStringResponder(500, ""))
	client := Client{APIKey: "abcdef", Secret: "abcdef", ProjectID: 1}

	_, err := client.ListFiles(1, 1)
	assert.Equal(t, err, fmt.Errorf("bad status: %d", 500))
}
Example #17
0
func TestDeleteFileWithSuccess(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterNoResponder(httpmock.NewStringResponder(200, ""))
	client := Client{APIKey: "abcdef", Secret: "abcdef", ProjectID: 1}

	err := client.DeleteFile("test.yml")
	assert.Nil(t, err)
}
Example #18
0
func TestGetTranslationsStatusWithFailure(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterNoResponder(httpmock.NewStringResponder(500, ""))
	client := Client{APIKey: "abcdef", Secret: "abcdef", ProjectID: 1}

	_, err := client.GetTranslationsStatus("string.po", "ja-JP")
	assert.Equal(t, err, fmt.Errorf("bad status: %d", 500))
}
Example #19
0
func TestImportTasksWithFailure(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterNoResponder(httpmock.NewStringResponder(500, ""))
	client := Client{APIKey: "abcdef", Secret: "abcdef", ProjectID: 1}

	_, err := client.ImportTasks(map[string]interface{}{"page": 1, "per_page": 50, "status": "all"})
	assert.Equal(t, err, fmt.Errorf("bad status: %d", 500))
}
Example #20
0
func TestVeryfiClient(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterResponder("GET", "https://rest.akismet.com/1.1/verify-key?blog=test_site&key=test_api_key", httpmock.NewStringResponder(200, `valid`))

	client := NewClient("test_api_key", "test_site")
	err := client.VeryfiClient()
	assert.Nil(t, err)
}
Example #21
0
func TestGetProviders(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	mock.RegisterProviderMocks()

	client := NewLytics(mock.MockApiKey, nil, nil)
	provider, err := client.GetProviders()
	assert.Equal(t, err, nil)
	assert.T(t, len(provider) > 1)
}
Example #22
0
func TestGetAuths(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	mock.RegisterAuthMocks()

	client := NewLytics(mock.MockApiKey, nil, nil)
	auths, err := client.GetAuths()
	assert.Equal(t, err, nil)
	assert.T(t, len(auths) > 1)
}
Example #23
0
func TestPostsGetTooManyTags(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	tags := []string{"one", "two", "three", "four"}
	_, _, err := client.Posts.Get(tags, nil, "")
	if err == nil {
		t.Error(err)
	}
}
Example #24
0
func TestGetUser(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	mock.RegisterUserMocks()

	client := NewLytics(mock.MockApiKey, nil, nil)
	user, err := client.GetUser(mock.MockUserID)
	assert.Equal(t, err, nil)
	assert.T(t, user.Id == mock.MockUserID)
}
Example #25
0
func TestRunApi(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	setupMock()

	tests := getTests()

	runner := NewRunner("http://testapi.my", RunnerConfig{})
	runner.Run(t, tests...)
}
Example #26
0
func setup() {
	app = App{
		ApiKey:      "apikey",
		ApiSecret:   "hush",
		RedirectUrl: "https://example.com/callback",
		Scope:       "read_products",
	}
	client = NewClient(app, "fooshop", "abcd")
	httpmock.Activate()
}
Example #27
0
func TestGetWork(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	mock.RegisterWorkMocks()

	client := NewLytics(mock.MockApiKey, nil, nil)
	work, err := client.GetWork(mock.MockWorkID, false)
	assert.Equal(t, err, nil)
	assert.T(t, work.Id == mock.MockWorkID)
}
Example #28
0
func TestSpamHamInvalid(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterResponder("GET", "https://test_api_key.rest.akismet.com/1.1/submit-ham?blog=test_site&user_agent=TestUserAgent&user_ip=127.0.0.1", httpmock.NewStringResponder(200, "invalid"))

	client := NewClient("test_api_key", "test_site")
	options := Options{UserIP: "127.0.0.1", UserAgent: "TestUserAgent"}
	err := client.SubmitHam(options)
	assert.Error(t, err)
}
Example #29
0
func TestSubmitHamTrue(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterResponder("GET", "https://test_api_key.rest.akismet.com/1.1/submit-ham?blog=test_site&user_agent=TestUserAgent&user_ip=127.0.0.1", httpmock.NewStringResponder(200, "Thanks for making the web a better place."))

	client := NewClient("test_api_key", "test_site")
	options := Options{UserIP: "127.0.0.1", UserAgent: "TestUserAgent"}
	err := client.SubmitHam(options)
	assert.Nil(t, err)
}
Example #30
0
func TestIsSpamInternal(t *testing.T) {
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterResponder("GET", "https://test_api_key.rest.akismet.com/1.1/comment-check?blog=test_site&user_agent=TestUserAgent&user_ip=127.0.0.1", httpmock.NewStringResponder(500, ""))

	client := NewClient("test_api_key", "test_site")
	options := Options{UserIP: "127.0.0.1", UserAgent: "TestUserAgent"}
	_, err := client.IsSpam(options)
	assert.Error(t, err)
}