client.expectError - Code Metrics - Inspection of "test: mock with testify" - viasite/planfix-toggl-server - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 91cacf...7ca05e )

by Stanislav

created 2018-03-03 23:39 UTC

client.expectError A

↳ Parent: app/client/client_test.go

Complexity

Conditions

Size

Total Lines	3
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	3
nop	3
dl	0
loc	3
rs	10
c	0
b	0
f	0

package client

import (
	"testing"
	"log"
	"github.com/viasite/planfix-toggl-server/app/config"
	"github.com/popstas/planfix-go/planfix"
	"net/http/httptest"
	"net/http"
	"io/ioutil"
	"encoding/xml"
	"github.com/popstas/go-toggl"
	"reflect"
	"time"
	"bytes"
	"strings"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
)

var output bytes.Buffer

type planfixRequestStruct struct {
	XMLName xml.Name `xml:"request"`
	Method  string   `xml:"method,attr"`
	Account string   `xml:"account"`
	Sid     string   `xml:"sid"`
}

func fixtureFromFile(fixtureName string) string {
	buf, _ := ioutil.ReadFile("../../tests/fixtures/" + fixtureName)
	return string(buf)
}

type MockedServer struct {
	*httptest.Server
	Requests  [][]byte
	Responses []string // fifo queue of answers
}

func NewMockedServer(responses []string) *MockedServer {
	s := &MockedServer{
		Requests:  [][]byte{},
		Responses: responses,
	}

	s.Server = httptest.NewServer(s)
	return s
}

func (s *MockedServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
	lastRequest, err := ioutil.ReadAll(req.Body)
	if err != nil {
		panic(err)
	}

	rs := planfixRequestStruct{}
	err = xml.Unmarshal(lastRequest, &rs)
	if err != nil {
		panic(err)
	}
	s.Requests = append(s.Requests, lastRequest)
	answer := s.Responses[0]

	s.Responses = s.Responses[1:]
	resp.Write([]byte(answer))
}

type MockedTogglSession struct {
	mock.Mock
	TogglSession
}

func (s *MockedTogglSession) GetAccount() (toggl.Account, error) {
	args := s.Called()
	return args.Get(0).(toggl.Account), args.Error(1)
}

func (s *MockedTogglSession) GetDetailedReport(workspace int, since, until string, page int) (toggl.DetailedReport, error) {
	args := s.Called(workspace, since, until, page)
	return args.Get(0).(toggl.DetailedReport), args.Error(1)
}

func newClient() TogglClient {
	cfg := config.Config{
		TogglSentTag:"sent",
	}
	api := planfix.New("", "apiKey", "account", "user", "password")
	api.Sid = "123"

	sess := &MockedTogglSession{}
	return TogglClient{
		Session:    sess,
		Config:     &cfg,
		PlanfixAPI: api,
		Logger:     log.New(&output, "", log.LstdFlags),
	}
}

func getTestEntries() []TogglPlanfixEntry {
	return []TogglPlanfixEntry{
		{
			toggl.DetailedTimeEntry{Duration: 1},
			PlanfixEntryData{TaskID: 1, GroupCount: 1},
		},
		{
			toggl.DetailedTimeEntry{Duration: 2},
			PlanfixEntryData{TaskID: 1, GroupCount: 1},
		},
		{
			toggl.DetailedTimeEntry{Duration: 3},
			PlanfixEntryData{TaskID: 2, GroupCount: 1},
		},
		{
			toggl.DetailedTimeEntry{Duration: 4},
			PlanfixEntryData{TaskID: 2, GroupCount: 1},
		},
		{
			toggl.DetailedTimeEntry{Duration: 5},
			PlanfixEntryData{TaskID: 2, GroupCount: 1},
		},
		{
			toggl.DetailedTimeEntry{Duration: 6},
			PlanfixEntryData{TaskID: 3, GroupCount: 1},
		},
	}
}

func getTestGroupedEntries() map[int][]TogglPlanfixEntry {
	return map[int][]TogglPlanfixEntry{
		1: {
			{
				toggl.DetailedTimeEntry{Duration: 1},
				PlanfixEntryData{TaskID: 1, GroupCount: 1},
			},
			{
				toggl.DetailedTimeEntry{Duration: 2},
				PlanfixEntryData{TaskID: 1, GroupCount: 1},
			},
		},
		2: {
			{
				toggl.DetailedTimeEntry{Duration: 3},
				PlanfixEntryData{TaskID: 2, GroupCount: 1},
			},
			{
				toggl.DetailedTimeEntry{Duration: 4},
				PlanfixEntryData{TaskID: 2, GroupCount: 1},
			},
			{
				toggl.DetailedTimeEntry{Duration: 5},
				PlanfixEntryData{TaskID: 2, GroupCount: 1},
			},
		},
		3: {
			{
				toggl.DetailedTimeEntry{Duration: 6},
				PlanfixEntryData{TaskID: 3, GroupCount: 1},
			},
		},
	}
}

func TestTogglClient_SumEntriesGroup(t *testing.T) {
	c := newClient()
	groupedEntries := getTestGroupedEntries()
	expected := []TogglPlanfixEntry{
		{
			toggl.DetailedTimeEntry{Duration: 3},
			PlanfixEntryData{TaskID: 1, GroupCount: 2},
		},
		{
			toggl.DetailedTimeEntry{Duration: 12},
			PlanfixEntryData{TaskID: 2, GroupCount: 3},
		},
		{
			toggl.DetailedTimeEntry{Duration: 6},
			PlanfixEntryData{TaskID: 3, GroupCount: 1},
		},
	}

	summed := c.SumEntriesGroup(groupedEntries)
	equals := reflect.DeepEqual(summed, expected)
	assert.Equal(t, equals, true)
}

func TestTogglClient_GroupEntriesByTask(t *testing.T) {
	c := newClient()
	entries := getTestEntries()
	expected := getTestGroupedEntries()

	grouped := c.GroupEntriesByTask(entries)
	equals := reflect.DeepEqual(grouped, expected)
	assert.Equal(t, equals, true)
}

func TestTogglClient_GroupEntriesByTask_empty(t *testing.T) {
	c := newClient()
	entries := []TogglPlanfixEntry{}
	expected := map[int][]TogglPlanfixEntry{}

	grouped := c.GroupEntriesByTask(entries)
	equals := reflect.DeepEqual(grouped, expected)
	assert.Equal(t, equals, true)
}

func TestTogglClient_sendEntries_dryRun(t *testing.T) {
	c := newClient()
	c.Config.DryRun = true
	now := time.Now()
	entries := []TogglPlanfixEntry{
		{
			toggl.DetailedTimeEntry{
				Duration:    60000,
				Start:       &now,
				Project:     "project",
				Description: "description",
			},
			PlanfixEntryData{TaskID: 1, GroupCount: 1},
		},
		{
			toggl.DetailedTimeEntry{Duration: 120000},
			PlanfixEntryData{TaskID: 1, GroupCount: 1},
		},
	}

	c.sendEntries(1, entries)
	assert.Equal(t, strings.Contains(output.String(), "[DEBUG] sending [project] description (3)"), true)
	assert.Equal(t, strings.Contains(output.String(), "[DEBUG] dry-run"), true)
}

func TestTogglClient_GetTogglUserID(t *testing.T) {
	c := newClient()
	sess := &MockedTogglSession{}
	c.Session = sess

	togglUser := toggl.Account{Data: struct {
		APIToken        string            `json:"api_token"`
		Timezone        string            `json:"timezone"`
		ID              int               `json:"id"`
		Workspaces      []toggl.Workspace `json:"workspaces"`
		Clients         []toggl.Client    `json:"clients"`
		Projects        []toggl.Project   `json:"projects"`
		Tasks           []toggl.Task      `json:"tasks"`
		Tags            []toggl.Tag       `json:"tags"`
		TimeEntries     []toggl.TimeEntry `json:"time_entries"`
		BeginningOfWeek int               `json:"beginning_of_week"`
	}{ID: 123}}
	sess.On("GetAccount").Return(togglUser, nil)

	togglUserID := c.GetTogglUserID()
	assert.Equal(t, togglUserID, 123)
}

func TestTogglClient_GetPlanfixUserID(t *testing.T) {
	c := newClient()
	ms := NewMockedServer([]string{
		fixtureFromFile("user.get.xml"),
		//fixtureFromFile("error.xml"),
	})
	c.PlanfixAPI.URL = ms.URL

	planfixUserID := c.GetPlanfixUserID()
	assert.Equal(t, planfixUserID, 9230)
}

func TestTogglClient_GetEntries(t *testing.T) {
	c := newClient()
	sess := &MockedTogglSession{}
	c.Session = sess

	since := time.Now().AddDate(0, 0, -30).Format("2006-01-02")
	until := time.Now().AddDate(0, 0, 1).Format("2006-01-02")
	report := toggl.DetailedReport{Data:[]toggl.DetailedTimeEntry{
		{
			ID: 1,
			Project: "project1",
			Description: "description1",
			Tags: []string{"12345", "sent"},
		},
	}}

	sess.On("GetDetailedReport", 234, since, until, 1).Return(report, nil)

	report, _ = c.Session.GetDetailedReport(234, since, until, 1)
	entries, _ := c.GetEntries(234, since, until)

	expected := []TogglPlanfixEntry{
		{
			DetailedTimeEntry: report.Data[0],
			Planfix: PlanfixEntryData{GroupCount:1, Sent:true, TaskID:12345},
		},
	}
	assert.Equal(t, entries, expected)
}

1			package client
2
3			import (
4			"testing"
5			"log"
6			"github.com/viasite/planfix-toggl-server/app/config"
7			"github.com/popstas/planfix-go/planfix"
8			"net/http/httptest"
9			"net/http"
10			"io/ioutil"
11			"encoding/xml"
12			"github.com/popstas/go-toggl"
13			"reflect"
14			"time"
15			"bytes"
16			"strings"
17			"github.com/stretchr/testify/assert"
18			"github.com/stretchr/testify/mock"
19			)
20
21			var output bytes.Buffer
22
23			type planfixRequestStruct struct {
24			XMLName xml.Name `xml:"request"`
25			Method string `xml:"method,attr"`
26			Account string `xml:"account"`
27			Sid string `xml:"sid"`
28			}
29
30			func fixtureFromFile(fixtureName string) string {
31			buf, _ := ioutil.ReadFile("../../tests/fixtures/" + fixtureName)
32			return string(buf)
33			}
34
35			type MockedServer struct {
36			*httptest.Server
37			Requests [][]byte
38			Responses []string // fifo queue of answers
39			}
40
41			func NewMockedServer(responses []string) *MockedServer {
42			s := &MockedServer{
43			Requests: [][]byte{},
44			Responses: responses,
45			}
46
47			s.Server = httptest.NewServer(s)
48			return s
49			}
50
51			func (s MockedServer) ServeHTTP(resp http.ResponseWriter, req http.Request) {
52			lastRequest, err := ioutil.ReadAll(req.Body)
53			if err != nil {
54			panic(err)
55			}
56
57			rs := planfixRequestStruct{}
58			err = xml.Unmarshal(lastRequest, &rs)
59			if err != nil {
60			panic(err)
61			}
62			s.Requests = append(s.Requests, lastRequest)
63			answer := s.Responses[0]
64
65			s.Responses = s.Responses[1:]
66			resp.Write([]byte(answer))
67			}
68
69			type MockedTogglSession struct {
70			mock.Mock
71			TogglSession
72			}
73
74			func (s *MockedTogglSession) GetAccount() (toggl.Account, error) {
75			args := s.Called()
76			return args.Get(0).(toggl.Account), args.Error(1)
77			}
78
79			func (s *MockedTogglSession) GetDetailedReport(workspace int, since, until string, page int) (toggl.DetailedReport, error) {
80			args := s.Called(workspace, since, until, page)
81			return args.Get(0).(toggl.DetailedReport), args.Error(1)
82			}
83
84			func newClient() TogglClient {
85			cfg := config.Config{
86			TogglSentTag:"sent",
87			}
88			api := planfix.New("", "apiKey", "account", "user", "password")
89			api.Sid = "123"
90
91			sess := &MockedTogglSession{}
92			return TogglClient{
93			Session: sess,
94			Config: &cfg,
95			PlanfixAPI: api,
96			Logger: log.New(&output, "", log.LstdFlags),
97			}
98			}
99
100			func getTestEntries() []TogglPlanfixEntry {
101			return []TogglPlanfixEntry{
102			{
103			toggl.DetailedTimeEntry{Duration: 1},
104			PlanfixEntryData{TaskID: 1, GroupCount: 1},
105			},
106			{
107			toggl.DetailedTimeEntry{Duration: 2},
108			PlanfixEntryData{TaskID: 1, GroupCount: 1},
109			},
110			{
111			toggl.DetailedTimeEntry{Duration: 3},
112			PlanfixEntryData{TaskID: 2, GroupCount: 1},
113			},
114			{
115			toggl.DetailedTimeEntry{Duration: 4},
116			PlanfixEntryData{TaskID: 2, GroupCount: 1},
117			},
118			{
119			toggl.DetailedTimeEntry{Duration: 5},
120			PlanfixEntryData{TaskID: 2, GroupCount: 1},
121			},
122			{
123			toggl.DetailedTimeEntry{Duration: 6},
124			PlanfixEntryData{TaskID: 3, GroupCount: 1},
125			},
126			}
127			}
128
129			func getTestGroupedEntries() map[int][]TogglPlanfixEntry {
130			return map[int][]TogglPlanfixEntry{
131			1: {
132			{
133			toggl.DetailedTimeEntry{Duration: 1},
134			PlanfixEntryData{TaskID: 1, GroupCount: 1},
135			},
136			{
137			toggl.DetailedTimeEntry{Duration: 2},
138			PlanfixEntryData{TaskID: 1, GroupCount: 1},
139			},
140			},
141			2: {
142			{
143			toggl.DetailedTimeEntry{Duration: 3},
144			PlanfixEntryData{TaskID: 2, GroupCount: 1},
145			},
146			{
147			toggl.DetailedTimeEntry{Duration: 4},
148			PlanfixEntryData{TaskID: 2, GroupCount: 1},
149			},
150			{
151			toggl.DetailedTimeEntry{Duration: 5},
152			PlanfixEntryData{TaskID: 2, GroupCount: 1},
153			},
154			},
155			3: {
156			{
157			toggl.DetailedTimeEntry{Duration: 6},
158			PlanfixEntryData{TaskID: 3, GroupCount: 1},
159			},
160			},
161			}
162			}
163
164			func TestTogglClient_SumEntriesGroup(t *testing.T) {
165			c := newClient()
166			groupedEntries := getTestGroupedEntries()
167			expected := []TogglPlanfixEntry{
168			{
169			toggl.DetailedTimeEntry{Duration: 3},
170			PlanfixEntryData{TaskID: 1, GroupCount: 2},
171			},
172			{
173			toggl.DetailedTimeEntry{Duration: 12},
174			PlanfixEntryData{TaskID: 2, GroupCount: 3},
175			},
176			{
177			toggl.DetailedTimeEntry{Duration: 6},
178			PlanfixEntryData{TaskID: 3, GroupCount: 1},
179			},
180			}
181
182			summed := c.SumEntriesGroup(groupedEntries)
183			equals := reflect.DeepEqual(summed, expected)
184			assert.Equal(t, equals, true)
185			}
186
187			func TestTogglClient_GroupEntriesByTask(t *testing.T) {
188			c := newClient()
189			entries := getTestEntries()
190			expected := getTestGroupedEntries()
191
192			grouped := c.GroupEntriesByTask(entries)
193			equals := reflect.DeepEqual(grouped, expected)
194			assert.Equal(t, equals, true)
195			}
196
197			func TestTogglClient_GroupEntriesByTask_empty(t *testing.T) {
198			c := newClient()
199			entries := []TogglPlanfixEntry{}
200			expected := map[int][]TogglPlanfixEntry{}
201
202			grouped := c.GroupEntriesByTask(entries)
203			equals := reflect.DeepEqual(grouped, expected)
204			assert.Equal(t, equals, true)
205			}
206
207			func TestTogglClient_sendEntries_dryRun(t *testing.T) {
208			c := newClient()
209			c.Config.DryRun = true
210			now := time.Now()
211			entries := []TogglPlanfixEntry{
212			{
213			toggl.DetailedTimeEntry{
214			Duration: 60000,
215			Start: &now,
216			Project: "project",
217			Description: "description",
218			},
219			PlanfixEntryData{TaskID: 1, GroupCount: 1},
220			},
221			{
222			toggl.DetailedTimeEntry{Duration: 120000},
223			PlanfixEntryData{TaskID: 1, GroupCount: 1},
224			},
225			}
226
227			c.sendEntries(1, entries)
228			assert.Equal(t, strings.Contains(output.String(), "[DEBUG] sending [project] description (3)"), true)
229			assert.Equal(t, strings.Contains(output.String(), "[DEBUG] dry-run"), true)
230			}
231
232			func TestTogglClient_GetTogglUserID(t *testing.T) {
233			c := newClient()
234			sess := &MockedTogglSession{}
235			c.Session = sess
236
237			togglUser := toggl.Account{Data: struct {
238			APIToken string `json:"api_token"`
239			Timezone string `json:"timezone"`
240			ID int `json:"id"`
241			Workspaces []toggl.Workspace `json:"workspaces"`
242			Clients []toggl.Client `json:"clients"`
243			Projects []toggl.Project `json:"projects"`
244			Tasks []toggl.Task `json:"tasks"`
245			Tags []toggl.Tag `json:"tags"`
246			TimeEntries []toggl.TimeEntry `json:"time_entries"`
247			BeginningOfWeek int `json:"beginning_of_week"`
248			}{ID: 123}}
249			sess.On("GetAccount").Return(togglUser, nil)
250
251			togglUserID := c.GetTogglUserID()
252			assert.Equal(t, togglUserID, 123)
253			}
254
255			func TestTogglClient_GetPlanfixUserID(t *testing.T) {
256			c := newClient()
257			ms := NewMockedServer([]string{
258			fixtureFromFile("user.get.xml"),
259			//fixtureFromFile("error.xml"),
260			})
261			c.PlanfixAPI.URL = ms.URL
262
263			planfixUserID := c.GetPlanfixUserID()
264			assert.Equal(t, planfixUserID, 9230)
265			}
266
267			func TestTogglClient_GetEntries(t *testing.T) {
268			c := newClient()
269			sess := &MockedTogglSession{}
270			c.Session = sess
271
272			since := time.Now().AddDate(0, 0, -30).Format("2006-01-02")
273			until := time.Now().AddDate(0, 0, 1).Format("2006-01-02")
274			report := toggl.DetailedReport{Data:[]toggl.DetailedTimeEntry{
275			{
276			ID: 1,
277			Project: "project1",
278			Description: "description1",
279			Tags: []string{"12345", "sent"},
280			},
281			}}
282
283			sess.On("GetDetailedReport", 234, since, until, 1).Return(report, nil)
284
285			report, _ = c.Session.GetDetailedReport(234, since, until, 1)
286			entries, _ := c.GetEntries(234, since, until)
287
288			expected := []TogglPlanfixEntry{
289			{
290			DetailedTimeEntry: report.Data[0],
291			Planfix: PlanfixEntryData{GroupCount:1, Sent:true, TaskID:12345},
292			},
293			}
294			assert.Equal(t, entries, expected)
295			}

viasite / planfix-toggl-server

Push — master ( 91cacf...7ca05e )

client.expectError A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like