How to use TS method of internal_test Package

1// Copyright 2018, OpenCensus Authors
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package internal_test
16
17import (
18	"testing"
19	"time"
20
21	"github.com/census-instrumentation/opencensus-service/internal"
22)
23
24func TestTimeConverters(t *testing.T) {
25	// Ensure that we nanoseconds but that they are also preserved.
26	t1 := time.Date(2018, 10, 31, 19, 43, 35, 789, time.UTC)
27	ts := internal.TimeToTimestamp(t1)
28	t2 := time.Unix(ts.Seconds, int64(ts.Nanos))
29
30	// Verification for paranoia
31	if g, w := int64(1541015015000000789), t1.UnixNano(); g != w {
32		t.Errorf("InitialTime time nanos mismatch\nGot: %d\nWant:%d", g, w)
33	}
34	if g, w := int64(1541015015000000789), t2.UnixNano(); g != w {
35		t.Errorf("Convertedback time nanos mismatch\nGot: %d\nWant:%d", g, w)
36	}
37	if g, w := t1.UnixNano(), t2.UnixNano(); g != w {
38		t.Errorf("Convertedback time does not match original time\nGot: %d\nWant:%d", g, w)
39	}
40}
41

Source: internal_test.go

// Copyright 2018, OpenCensus Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package internal_test

import (
	"testing"
	"time"

	"github.com/census-instrumentation/opencensus-service/internal"
)

func TestTimeConverters(t *testing.T) {
	// Ensure that we nanoseconds but that they are also preserved.
	t1 := time.Date(2018, 10, 31, 19, 43, 35, 789, time.UTC)
	ts := internal.TimeToTimestamp(t1)
	t2 := time.Unix(ts.Seconds, int64(ts.Nanos))

	// Verification for paranoia
	if g, w := int64(1541015015000000789), t1.UnixNano(); g != w {
		t.Errorf("InitialTime time nanos mismatch\nGot: %d\nWant:%d", g, w)
	}
	if g, w := int64(1541015015000000789), t2.UnixNano(); g != w {
		t.Errorf("Convertedback time nanos mismatch\nGot: %d\nWant:%d", g, w)
	}
	if g, w := t1.UnixNano(), t2.UnixNano(); g != w {
		t.Errorf("Convertedback time does not match original time\nGot: %d\nWant:%d", g, w)
	}
}

1package internal_test
2
3import (
4	"io/ioutil"
5	"net/http"
6	"net/http/httptest"
7	"testing"
8
9	"github.com/grommers00/civitas/backend/internal"
10	"github.com/stretchr/testify/assert"
11)
12
13// ErrorTestHandler removes duplicate err handling logic
14func ErrorTestHandler(err error, t *testing.T) {
15	if err != nil {
16		t.Errorf("Err: %d", err)
17	}
18}
19
20func TestNotImplementedHandler(t *testing.T) {
21	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
22		internal.NotImplementedHandler("Test", w)
23	}))
24	defer ts.Close()
25
26	res, err := http.Get(ts.URL)
27	ErrorTestHandler(err, t)
28
29	results, err := ioutil.ReadAll(res.Body)
30	res.Body.Close()
31	ErrorTestHandler(err, t)
32
33	if string(results) != "Test Not Implemented!\n" {
34		t.Error("Expected result to be 'Test Not Implemented!\n'")
35	}
36}
37
38func TestUnwrapJSONData(t *testing.T) {
39	type TestJSONLoading struct {
40		ID   int    `json:"id"`
41		Game string `json:"game"`
42	}
43
44	t.Run("Valid PATH", func(t *testing.T) {
45		ErrorTestHandler(internal.UnwrapJSONData("../mockdata/mocktests.json", &TestJSONLoading{}), t)
46	})
47
48	t.Run("Invalid PATH", func(t *testing.T) {
49		err := internal.UnwrapJSONData("../badpath/mocktests.json", &TestJSONLoading{})
50		assert.NotEqual(t, err, nil)
51	})
52}
53

Source: devel_test.go

package internal_test

import (
	"io/ioutil"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/grommers00/civitas/backend/internal"
	"github.com/stretchr/testify/assert"
)

// ErrorTestHandler removes duplicate err handling logic
func ErrorTestHandler(err error, t *testing.T) {
	if err != nil {
		t.Errorf("Err: %d", err)
	}
}

func TestNotImplementedHandler(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		internal.NotImplementedHandler("Test", w)
	}))
	defer ts.Close()

	res, err := http.Get(ts.URL)
	ErrorTestHandler(err, t)

	results, err := ioutil.ReadAll(res.Body)
	res.Body.Close()
	ErrorTestHandler(err, t)

	if string(results) != "Test Not Implemented!\n" {
		t.Error("Expected result to be 'Test Not Implemented!\n'")
	}
}

func TestUnwrapJSONData(t *testing.T) {
	type TestJSONLoading struct {
		ID   int    `json:"id"`
		Game string `json:"game"`
	}

	t.Run("Valid PATH", func(t *testing.T) {
		ErrorTestHandler(internal.UnwrapJSONData("../mockdata/mocktests.json", &TestJSONLoading{}), t)
	})

	t.Run("Invalid PATH", func(t *testing.T) {
		err := internal.UnwrapJSONData("../badpath/mocktests.json", &TestJSONLoading{})
		assert.NotEqual(t, err, nil)
	})
}