Esempio n. 1
11
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)
	}
}
Esempio n. 2
0
func TestOrderCount(t *testing.T) {
	setup()
	defer teardown()

	httpmock.RegisterResponder("GET", "https://fooshop.myshopify.com/admin/orders/count.json",
		httpmock.NewStringResponder(200, `{"count": 7}`))

	httpmock.RegisterResponder("GET", "https://fooshop.myshopify.com/admin/orders/count.json?created_at_min=2016-01-01T00%3A00%3A00Z",
		httpmock.NewStringResponder(200, `{"count": 2}`))

	cnt, err := client.Order.Count(nil)
	if err != nil {
		t.Errorf("Order.Count returned error: %v", err)
	}

	expected := 7
	if cnt != expected {
		t.Errorf("Order.Count returned %d, expected %d", cnt, expected)
	}

	date := time.Date(2016, time.January, 1, 0, 0, 0, 0, time.UTC)
	cnt, err = client.Order.Count(CountOptions{CreatedAtMin: date})
	if err != nil {
		t.Errorf("Order.Count returned error: %v", err)
	}

	expected = 2
	if cnt != expected {
		t.Errorf("Order.Count returned %d, expected %d", cnt, expected)
	}
}
Esempio n. 3
0
func setHasMoreResponderPutValid() {
	httpmock.RegisterResponder("POST", "http://arangodb:8000/_db/dbName/path",
		httpmock.NewStringResponder(200, `{"error": false, "errorMessage": "", "result": [{}], "hasMore":true, "id":"1000"}`))

	httpmock.RegisterResponder("PUT", "http://arangodb:8000/_db/dbName/path/1000",
		httpmock.NewStringResponder(200, `{"error": false, "errorMessage": "", "result": [{}], "hasMore":false}`))
}
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")

	})
}
Esempio n. 5
0
func TestWebhookCount(t *testing.T) {
	setup()
	defer teardown()

	httpmock.RegisterResponder("GET", "https://fooshop.myshopify.com/admin/webhooks/count.json",
		httpmock.NewStringResponder(200, `{"count": 7}`))

	httpmock.RegisterResponder("GET", "https://fooshop.myshopify.com/admin/webhooks/count.json?topic=orders%2Fpaid",
		httpmock.NewStringResponder(200, `{"count": 2}`))

	cnt, err := client.Webhook.Count(nil)
	if err != nil {
		t.Errorf("Webhook.Count returned error: %v", err)
	}

	expected := 7
	if cnt != expected {
		t.Errorf("Webhook.Count returned %d, expected %d", cnt, expected)
	}

	options := WebhookOptions{Topic: "orders/paid"}
	cnt, err = client.Webhook.Count(options)
	if err != nil {
		t.Errorf("Webhook.Count returned error: %v", err)
	}

	expected = 2
	if cnt != expected {
		t.Errorf("Webhook.Count returned %d, expected %d", cnt, expected)
	}
}
Esempio n. 6
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"))
}
Esempio n. 7
0
func TestCount(t *testing.T) {
	setup()
	defer teardown()

	httpmock.RegisterResponder("GET", "https://fooshop.myshopify.com/foocount",
		httpmock.NewStringResponder(200, `{"count": 5}`))

	httpmock.RegisterResponder("GET", "https://fooshop.myshopify.com/foocount?created_at_min=2016-01-01T00%3A00%3A00Z",
		httpmock.NewStringResponder(200, `{"count": 2}`))

	// Test without options
	cnt, err := client.Count("foocount", nil)
	if err != nil {
		t.Errorf("Client.Count returned error: %v", err)
	}

	expected := 5
	if cnt != expected {
		t.Errorf("Client.Count returned %d, expected %d", cnt, expected)
	}

	// Test with options
	date := time.Date(2016, time.January, 1, 0, 0, 0, 0, time.UTC)
	cnt, err = client.Count("foocount", CountOptions{CreatedAtMin: date})
	if err != nil {
		t.Errorf("Client.Count returned error: %v", err)
	}

	expected = 2
	if cnt != expected {
		t.Errorf("Client.Count returned %d, expected %d", cnt, expected)
	}
}
Esempio n. 8
0
// TestQueryRun runs tests on the Query Run method.
func TestQueryRun(t *testing.T) {
	a := assert.New(t)
	r := require.New(t)

	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	db := New().LoggerOptions(false, false, false)
	db.Connect("http://arangodb:8000", "dbName", "foo", "bar")

	result, err := db.Run(NewQuery(shortQuery))
	r.Error(err)
	a.Nil(result)

	httpmock.RegisterResponder("POST", "http://arangodb:8000/_db/dbName/_api/cursor",
		httpmock.NewStringResponder(200, `{"error": false, "errorMessage": "", "result": []}`))

	result, err = db.Run(NewQuery(""))
	r.NoError(err)
	a.Equal("[]", string(result))

	result, err = db.Run(NewQuery(shortQuery).Cache(true).BatchSize(500))
	r.NoError(err)
	a.Equal("[]", string(result))

	httpmock.RegisterResponder("POST", "http://arangodb:8000/_db/dbName/_api/cursor",
		httpmock.NewStringResponder(200, `{"error": false, "errorMessage": "", "result": [{}], "hasMore":true, "id":"1000"}`))

	httpmock.RegisterResponder("PUT", "http://arangodb:8000/_db/dbName/_api/cursor/1000",
		httpmock.NewStringResponder(200, `{"error": false, "errorMessage": "", "result": [{}], "hasMore":false}`))

	result, err = db.Run(NewQuery(""))
	r.NoError(err)
	a.Equal("[{},{}]", string(result))

	q := NewQuery(`
	    FOR d
	    IN documents
	    FILTER d._key == @key
	    RETURN d
	    `)
	q.Bind("key", 1000)
	result, err = db.Run(q)

	r.NoError(err)
	a.Equal("[{},{}]", string(result))

	httpmock.RegisterResponder("POST", "http://arangodb:8000/_db/dbName/_api/cursor",
		httpmock.NewStringResponder(500, `{"error": true, "errorMessage": "error !"}`))

	result, err = db.Run(NewQuery(shortQuery))
	r.Error(err)
	a.Nil(result)
}
Esempio n. 9
0
func TestOrderListOptions(t *testing.T) {
	setup()
	defer teardown()

	httpmock.RegisterResponder("GET", "https://fooshop.myshopify.com/admin/orders.json?limit=250&page=10&status=any",
		httpmock.NewBytesResponder(200, loadFixture("orders.json")))

	options := OrderListOptions{
		Page:   10,
		Limit:  250,
		Status: "any"}

	orders, err := client.Order.List(options)
	if err != nil {
		t.Errorf("Order.List returned error: %v", err)
	}

	// Check that orders were parsed
	if len(orders) != 1 {
		t.Errorf("Order.List got %v orders, expected: 1", len(orders))
	}

	order := orders[0]
	orderTests(t, order)
}
Esempio n. 10
0
func TestGetMultipleTemplates(t *testing.T) {
	assert := assert.New(t)
	output := new(bytes.Buffer)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterResponder("GET", templateUrl("Java.gitignore"),
		httpmock.NewStringResponder(200, "*.class"))
	httpmock.RegisterResponder("GET", templateUrl("Go.gitignore"),
		httpmock.NewStringResponder(200, "*.o"))

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

	assert.ThatString(output.String()).
		Contains(fmt.Sprintln("# Java\n*.class")).
		Contains(fmt.Sprintln("# Go\n*.o"))
}
func dataMarshalling(t *testing.T) {
	httpmock.RegisterResponder("GET", fetcher.generateURL(),
		httpmock.NewStringResponder(200, "{\"response\": {\"games\": [{\"appid\": 10, \"name\": \"game\", \"playtime_forever\": 32}]}}"))

	fetcher.getOwnedGames()
	assert.Equal(t, 10, fetcher.OwnedGames.Response.Games[0].ID)
}
Esempio n. 12
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)
		}
	}
}
Esempio n. 13
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)
	}
}
Esempio n. 14
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")
	}

}
Esempio n. 15
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)
	}
}
Esempio n. 16
0
func RegisterEntityMocks() {
	// *******************************************************
	// GET ENTITY
	// *******************************************************
	httpmock.RegisterResponder("GET", "https://api.lytics.io/api/entity/user/email/[email protected]",
		func(req *http.Request) (*http.Response, error) {
			var fail bool

			queries := req.URL.Query()

			if queries.Get("key") != MockApiKey {
				fail = true
			}

			if queries.Get("fields") == "score_intensity" {
				return httpmock.NewStringResponse(200, readJsonFile("get_entity_fields")), nil
			}

			if fail {
				return httpmock.NewStringResponse(401, readJsonFile("get_error")), nil
			}

			return httpmock.NewStringResponse(200, readJsonFile("get_entity")), nil
		},
	)
}
Esempio n. 17
0
func TestCJCourier(t *testing.T) {
	// create cj courier
	courier, _ := New("CJ")

	// create http mock
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	invalidTrackingNumber := "cj_invalid"
	startTrackingNumber := "cj_start"
	completeTrackingNumber := "cj_complete"

	httpmock.RegisterResponder("GET", fmt.Sprintf(Cj{}.TrackingUrl(), invalidTrackingNumber),
		httpmock.NewStringResponder(200, readTestResponseFile(invalidTrackingNumber+".html")))
	httpmock.RegisterResponder("GET", fmt.Sprintf(Cj{}.TrackingUrl(), startTrackingNumber),
		httpmock.NewStringResponder(200, readTestResponseFile(startTrackingNumber+".html")))
	httpmock.RegisterResponder("GET", fmt.Sprintf(Cj{}.TrackingUrl(), completeTrackingNumber),
		httpmock.NewStringResponder(200, readTestResponseFile(completeTrackingNumber+".html")))

	Convey("CJ test", t, func() {
		Convey("Invalid tracking number test", func() {
			_, err := courier.Parse(invalidTrackingNumber)

			So(err, ShouldNotBeNil)
		})

		Convey("Start courier test", func() {
			data, _ := courier.Parse(startTrackingNumber)

			So(data.StatusCode, ShouldEqual, delibird.DeleveryStart)
			So(data.Sender, ShouldEqual, "홈*럼")
			So(data.Receiver, ShouldEqual, "테*트")
			So(data.Signer, ShouldEqual, "")
			So(data.CompanyCode, ShouldEqual, "CJ")
		})

		Convey("Complete courier test", func() {
			data, _ := courier.Parse(completeTrackingNumber)

			So(data.StatusCode, ShouldEqual, delibird.DeleveryComplete)
			So(data.Sender, ShouldEqual, "홈*럼")
			So(data.Receiver, ShouldEqual, "테*트")
			So(data.Signer, ShouldEqual, "본인")
			So(data.CompanyCode, ShouldEqual, "CJ")
		})
	})
}
Esempio n. 18
0
func TestGetUniqueGlobalTemplate(t *testing.T) {
	assert := assert.New(t)
	output := new(bytes.Buffer)
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()
	httpmock.RegisterResponder("GET", templateUrl("Vagrant.gitignore"),
		httpmock.NewStringResponder(404, "Not Found"))
	httpmock.RegisterResponder("GET", templateUrl("Global/Vagrant.gitignore"),
		httpmock.NewStringResponder(200, ".vagrant/"))

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

	assert.ThatString(output.String()).IsEqualTo(
		`# Vagrant
.vagrant/
`)
}
Esempio n. 19
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)
}
Esempio n. 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)
}
Esempio n. 21
0
func MockHTTP() {
	httpmock.Activate()
	f, err := ioutil.ReadFile("testdata/feeds.xml")
	if err != nil {
		panic(err)
	}

	httpmock.RegisterResponder("GET", "https://github.com/pocke.private",
		httpmock.NewBytesResponder(http.StatusOK, f))

	f, err = ioutil.ReadFile("testdata/feeds_api.json")
	if err != nil {
		panic(err)
	}

	httpmock.RegisterResponder("GET", "https://api.github.com/feeds",
		httpmock.NewBytesResponder(http.StatusOK, f))
}
Esempio n. 22
0
// TestTransactionRun runs tests on the Transaction Run method.
func TestTransactionRun(t *testing.T) {
	a := assert.New(t)
	r := require.New(t)
	db := New().LoggerOptions(false, false, false)
	db.Connect("http://arangodb:8000", "dbName", "foo", "bar")

	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	result, err := db.Run(NewTransaction([]string{"foo"}, []string{"bar"}).
		AddQuery("var1", "FOR c IN customer RETURN c"))
	r.Error(err)
	a.Nil(result)

	httpmock.RegisterResponder("POST", "http://arangodb:8000/_db/dbName/_api/transaction",
		func(r *http.Request) (*http.Response, error) {
			buffer, _ := ioutil.ReadAll(r.Body)
			return httpmock.NewStringResponse(200, string(buffer)), nil
		})

	result, err = db.Run(NewTransaction(nil, nil))
	r.NoError(err)
	a.Equal("{\"collections\":{\"read\":[],\"write\":[]},\"action\":\"function () {var db = require(`internal`).db; }\"}", string(result))

	result, err = db.Run(NewTransaction([]string{"foo"}, []string{"bar"}).
		AddQuery("", "FOR c IN customer RETURN c"))
	r.NoError(err)
	a.Equal("{\"collections\":{\"read\":[\"foo\"],\"write\":[\"bar\"]},\"action\":\"function () {var db = require(`internal`).db; db._query(aqlQuery`FOR c IN customer RETURN c`).toArray(); }\"}", string(result))

	result, err = db.Run(NewTransaction([]string{"foo"}, []string{"bar"}).
		AddQuery("var1", "FOR c IN customer RETURN c").
		AddQuery("var2", "FOR c IN {{.var1}} RETURN c").
		Return("var1"))
	r.NoError(err)
	a.Equal("{\"collections\":{\"read\":[\"foo\"],\"write\":[\"bar\"]},\"action\":\"function () {var db = require(`internal`).db; var var1 = db._query(aqlQuery`FOR c IN customer RETURN c`).toArray(); var var2 = db._query(aqlQuery`FOR c IN ${var1} RETURN c`).toArray(); return var1;}\"}", string(result))

	httpmock.RegisterResponder("POST", "http://arangodb:8000/_db/dbName/_api/transaction",
		httpmock.NewStringResponder(500, `{"error": true, "errorMessage": "error !"}`))

	result, err = db.Run(NewTransaction([]string{"foo"}, []string{"bar"}).
		AddQuery("var1", "FOR c IN customer RETURN c"))
	r.Error(err)
	a.Nil(result)
}
Esempio n. 23
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)
}
Esempio n. 24
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)
}
Esempio n. 25
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)
}
Esempio n. 26
0
func RegisterSegmentMLMocks() {
	// *******************************************************
	// GET SINGLE SEGMENTML MODEL
	// *******************************************************
	httpmock.RegisterResponder("GET", "https://api.lytics.io/api/segmentml/"+MockSegmentMLID,
		func(req *http.Request) (*http.Response, error) {
			var fail bool

			queries := req.URL.Query()

			if queries.Get("key") != MockApiKey {
				fail = true
			}

			if fail {
				return httpmock.NewStringResponse(401, readJsonFile("get_error")), nil
			}

			return httpmock.NewStringResponse(200, readJsonFile("get_segmentml")), nil
		},
	)

	// *******************************************************
	// GET ALL SEGMENTML MODELS
	// *******************************************************
	httpmock.RegisterResponder("GET", "https://api.lytics.io/api/segmentml",
		func(req *http.Request) (*http.Response, error) {
			var fail bool

			queries := req.URL.Query()

			if queries.Get("key") != MockApiKey {
				fail = true
			}

			if fail {
				return httpmock.NewStringResponse(401, readJsonFile("get_error")), nil
			}

			return httpmock.NewStringResponse(200, readJsonFile("get_segmentml_models")), nil
		},
	)
}
Esempio n. 27
0
func RegisterUserMocks() {
	// *******************************************************
	// GET SINGLE USER
	// *******************************************************
	httpmock.RegisterResponder("GET", "https://api.lytics.io/api/user/"+MockUserID,
		func(req *http.Request) (*http.Response, error) {
			var fail bool

			queries := req.URL.Query()

			if queries.Get("key") != MockApiKey {
				fail = true
			}

			if fail {
				return httpmock.NewStringResponse(401, readJsonFile("get_error")), nil
			}

			return httpmock.NewStringResponse(200, readJsonFile("get_user")), nil
		},
	)

	// *******************************************************
	// GET ALL USERS FOR API KEY
	// *******************************************************
	httpmock.RegisterResponder("GET", "https://api.lytics.io/api/user",
		func(req *http.Request) (*http.Response, error) {
			var fail bool

			queries := req.URL.Query()

			if queries.Get("key") != MockApiKey {
				fail = true
			}

			if fail {
				return httpmock.NewStringResponse(401, readJsonFile("get_error")), nil
			}

			return httpmock.NewStringResponse(200, readJsonFile("get_users")), nil
		},
	)
}
Esempio n. 28
0
func RegisterWorkMocks() {
	// *******************************************************
	// GET SINGLE WORK
	// *******************************************************
	httpmock.RegisterResponder("GET", "https://api.lytics.io/api/work/"+MockWorkID,
		func(req *http.Request) (*http.Response, error) {
			var fail bool

			queries := req.URL.Query()

			if queries.Get("key") != MockApiKey {
				fail = true
			}

			if fail {
				return httpmock.NewStringResponse(401, readJsonFile("get_error")), nil
			}

			return httpmock.NewStringResponse(200, readJsonFile("get_work")), nil
		},
	)

	// *******************************************************
	// GET ALL AVAILABLE WORKS FOR API KEY
	// *******************************************************
	httpmock.RegisterResponder("GET", "https://api.lytics.io/api/work",
		func(req *http.Request) (*http.Response, error) {
			var fail bool

			queries := req.URL.Query()

			if queries.Get("key") != MockApiKey {
				fail = true
			}

			if fail {
				return httpmock.NewStringResponse(401, readJsonFile("get_error")), nil
			}

			return httpmock.NewStringResponse(200, readJsonFile("get_works")), nil
		},
	)
}
Esempio n. 29
0
func RegisterAccountMocks() {
	// *******************************************************
	// GET SINGLE ACCOUNT
	// *******************************************************
	httpmock.RegisterResponder("GET", "https://api.lytics.io/api/account/"+MockAccountID,
		func(req *http.Request) (*http.Response, error) {
			var fail bool

			queries := req.URL.Query()

			if queries.Get("key") != MockApiKey {
				fail = true
			}

			if fail {
				return httpmock.NewStringResponse(401, readJsonFile("get_error")), nil
			}

			return httpmock.NewStringResponse(200, readJsonFile("get_account")), nil
		},
	)

	// *******************************************************
	// GET ALL ACCOUNTS FOR API KEY
	// *******************************************************
	httpmock.RegisterResponder("GET", "https://api.lytics.io/api/account",
		func(req *http.Request) (*http.Response, error) {
			var fail bool

			queries := req.URL.Query()

			if queries.Get("key") != MockApiKey {
				fail = true
			}

			if fail {
				return httpmock.NewStringResponse(401, readJsonFile("get_error")), nil
			}

			return httpmock.NewStringResponse(200, readJsonFile("get_accounts")), nil
		},
	)
}
Esempio n. 30
0
func TestKGCourier(t *testing.T) {
	// create kg courier
	courier, _ := New("KG")

	// create http mock
	httpmock.Activate()
	defer httpmock.DeactivateAndReset()

	invalidTrackingNumber := "kg_invalid"
	invalidTrackingNumber2 := "kg_invalid2"
	completeTrackingNumber := "kg_complete"

	httpmock.RegisterResponder("GET", fmt.Sprintf(Kg{}.TrackingUrl(), invalidTrackingNumber),
		httpmock.NewStringResponder(200, readTestResponseFile(invalidTrackingNumber+".html")))
	httpmock.RegisterResponder("GET", fmt.Sprintf(Kg{}.TrackingUrl(), invalidTrackingNumber2),
		httpmock.NewStringResponder(200, readTestResponseFile(invalidTrackingNumber2+".html")))
	httpmock.RegisterResponder("GET", fmt.Sprintf(Kg{}.TrackingUrl(), completeTrackingNumber),
		httpmock.NewStringResponder(200, readTestResponseFile(completeTrackingNumber+".html")))

	Convey("KG test", t, func() {
		Convey("Invalid tracking number test", func() {
			_, err := courier.Parse(invalidTrackingNumber)

			So(err, ShouldNotBeNil)
		})
		Convey("Invalid tracking number test2", func() {
			_, err := courier.Parse(invalidTrackingNumber2)

			So(err, ShouldNotBeNil)
		})

		Convey("Complete courier test", func() {
			data, _ := courier.Parse(completeTrackingNumber)

			So(data.StatusCode, ShouldEqual, delibird.DeleveryComplete)
			So(data.Sender, ShouldEqual, "웨일런샵 님")
			So(data.Receiver, ShouldEqual, "김예준 님")
			So(data.CompanyCode, ShouldEqual, "KG")
		})
	})
}