app/client/client_test.go - Code Metrics - Inspection of "test: dry-run" - viasite/planfix-toggl-server - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3fcd0c...6a924e )

by Stanislav

created 2018-03-02 21:44 UTC

app/client/client_test.go A

↳ Parent: Project

Size/Duplication

Total Lines	211
Duplicated Lines	0 %

Importance

Changes

Metric	Value
cc	13
dl	0
loc	211
rs	10
c	0
b	0
f	0

10 Methods

Rating	Name	Size	Complexity
A	client.TestTogglClient_SumEntriesGroup	21	1
A	client.TestTogglClient_GroupEntriesByTask	8	1
A	client.*MockedServer.ServeHTTP	16	3
A	client.assert	3	2
A	client.getTestGroupedEntries	30	1
A	client.TestTogglClient_GroupEntriesByTask_empty	8	1
A	client.newClient	11	1
A	client.TestTogglClient_sendEntries_dryRun	23	1
A	client.getTestEntries	25	1
A	client.NewMockedServer	8	1

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"
)

var output bytes.Buffer

func assert(t *testing.T, data interface{}, expected interface{}) {
	if data != expected {
		t.Errorf("Expected %v, got, %v", expected, data)
	}
}

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

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))
}

func newClient() TogglClient {
	cfg := config.Config{}
	ms := NewMockedServer([]string{""})
	api := planfix.New(ms.URL, "apiKey", "account", "user", "password")
	api.Sid = "123"

	return TogglClient{
		Session:    toggl.OpenSession(cfg.TogglAPIToken),
		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(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(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(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(t, strings.Contains(output.String(), "[DEBUG] sending [project] description (3)"), true)
	assert(t, strings.Contains(output.String(), "[DEBUG] dry-run"), true)
}


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			)
18
19			var output bytes.Buffer
20
21			func assert(t *testing.T, data interface{}, expected interface{}) {
22			if data != expected {
23			t.Errorf("Expected %v, got, %v", expected, data)
24			}
25			}
26
27			type planfixRequestStruct struct {
28			XMLName xml.Name `xml:"request"`
29			Method string `xml:"method,attr"`
30			Account string `xml:"account"`
31			Sid string `xml:"sid"`
32			}
33
34			type MockedServer struct {
35			*httptest.Server
36			Requests [][]byte
37			Responses []string // fifo queue of answers
38			}
39
40			func NewMockedServer(responses []string) *MockedServer {
41			s := &MockedServer{
42			Requests: [][]byte{},
43			Responses: responses,
44			}
45
46			s.Server = httptest.NewServer(s)
47			return s
48			}
49
50			func (s MockedServer) ServeHTTP(resp http.ResponseWriter, req http.Request) {
51			lastRequest, err := ioutil.ReadAll(req.Body)
52			if err != nil {
53			panic(err)
54			}
55
56			rs := planfixRequestStruct{}
57			err = xml.Unmarshal(lastRequest, &rs)
58			if err != nil {
59			panic(err)
60			}
61			s.Requests = append(s.Requests, lastRequest)
62			answer := s.Responses[0]
63
64			s.Responses = s.Responses[1:]
65			resp.Write([]byte(answer))
66			}
67
68			func newClient() TogglClient {
69			cfg := config.Config{}
70			ms := NewMockedServer([]string{""})
71			api := planfix.New(ms.URL, "apiKey", "account", "user", "password")
72			api.Sid = "123"
73
74			return TogglClient{
75			Session: toggl.OpenSession(cfg.TogglAPIToken),
76			Config: &cfg,
77			PlanfixAPI: api,
78			Logger: log.New(&output, "", log.LstdFlags),
79			}
80			}
81
82			func getTestEntries() []TogglPlanfixEntry {
83			return []TogglPlanfixEntry{
84			{
85			toggl.DetailedTimeEntry{Duration: 1},
86			PlanfixEntryData{TaskID: 1, GroupCount: 1},
87			},
88			{
89			toggl.DetailedTimeEntry{Duration: 2},
90			PlanfixEntryData{TaskID: 1, GroupCount: 1},
91			},
92			{
93			toggl.DetailedTimeEntry{Duration: 3},
94			PlanfixEntryData{TaskID: 2, GroupCount: 1},
95			},
96			{
97			toggl.DetailedTimeEntry{Duration: 4},
98			PlanfixEntryData{TaskID: 2, GroupCount: 1},
99			},
100			{
101			toggl.DetailedTimeEntry{Duration: 5},
102			PlanfixEntryData{TaskID: 2, GroupCount: 1},
103			},
104			{
105			toggl.DetailedTimeEntry{Duration: 6},
106			PlanfixEntryData{TaskID: 3, GroupCount: 1},
107			},
108			}
109			}
110
111			func getTestGroupedEntries() map[int][]TogglPlanfixEntry {
112			return map[int][]TogglPlanfixEntry{
113			1: {
114			{
115			toggl.DetailedTimeEntry{Duration: 1},
116			PlanfixEntryData{TaskID: 1, GroupCount: 1},
117			},
118			{
119			toggl.DetailedTimeEntry{Duration: 2},
120			PlanfixEntryData{TaskID: 1, GroupCount: 1},
121			},
122			},
123			2: {
124			{
125			toggl.DetailedTimeEntry{Duration: 3},
126			PlanfixEntryData{TaskID: 2, GroupCount: 1},
127			},
128			{
129			toggl.DetailedTimeEntry{Duration: 4},
130			PlanfixEntryData{TaskID: 2, GroupCount: 1},
131			},
132			{
133			toggl.DetailedTimeEntry{Duration: 5},
134			PlanfixEntryData{TaskID: 2, GroupCount: 1},
135			},
136			},
137			3: {
138			{
139			toggl.DetailedTimeEntry{Duration: 6},
140			PlanfixEntryData{TaskID: 3, GroupCount: 1},
141			},
142			},
143			}
144			}
145
146			func TestTogglClient_SumEntriesGroup(t *testing.T) {
147			c := newClient()
148			groupedEntries := getTestGroupedEntries()
149			expected := []TogglPlanfixEntry{
150			{
151			toggl.DetailedTimeEntry{Duration: 3},
152			PlanfixEntryData{TaskID: 1, GroupCount: 2},
153			},
154			{
155			toggl.DetailedTimeEntry{Duration: 12},
156			PlanfixEntryData{TaskID: 2, GroupCount: 3},
157			},
158			{
159			toggl.DetailedTimeEntry{Duration: 6},
160			PlanfixEntryData{TaskID: 3, GroupCount: 1},
161			},
162			}
163
164			summed := c.SumEntriesGroup(groupedEntries)
165			equals := reflect.DeepEqual(summed, expected)
166			assert(t, equals, true)
167			}
168
169			func TestTogglClient_GroupEntriesByTask(t *testing.T) {
170			c := newClient()
171			entries := getTestEntries()
172			expected := getTestGroupedEntries()
173
174			grouped := c.GroupEntriesByTask(entries)
175			equals := reflect.DeepEqual(grouped, expected)
176			assert(t, equals, true)
177			}
178
179			func TestTogglClient_GroupEntriesByTask_empty(t *testing.T) {
180			c := newClient()
181			entries := []TogglPlanfixEntry{}
182			expected := map[int][]TogglPlanfixEntry{}
183
184			grouped := c.GroupEntriesByTask(entries)
185			equals := reflect.DeepEqual(grouped, expected)
186			assert(t, equals, true)
187			}
188
189			func TestTogglClient_sendEntries_dryRun(t *testing.T) {
190			c := newClient()
191			c.Config.DryRun = true
192			now := time.Now()
193			entries := []TogglPlanfixEntry{
194			{
195			toggl.DetailedTimeEntry{
196			Duration: 60000,
197			Start: &now,
198			Project: "project",
199			Description: "description",
200			},
201			PlanfixEntryData{TaskID: 1, GroupCount: 1},
202			},
203			{
204			toggl.DetailedTimeEntry{Duration: 120000},
205			PlanfixEntryData{TaskID: 1, GroupCount: 1},
206			},
207			}
208
209			c.sendEntries(1, entries)
210			assert(t, strings.Contains(output.String(), "[DEBUG] sending [project] description (3)"), true)
211			assert(t, strings.Contains(output.String(), "[DEBUG] dry-run"), true)
212			}
213

viasite / planfix-toggl-server

Push — master ( 3fcd0c...6a924e )

app/client/client_test.go A

Size/Duplication

Importance

10 Methods

Duplication Side-by-Side

Filter issues like