← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/altoros/gosigma/data/drives_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/altoros/gosigma/data/drives_test.go
 
1
// Copyright 2014 ALTOROS
 
2
// Licensed under the AGPLv3, see LICENSE file for details.
 
3
 
 
4
package data
 
5
 
 
6
import (
 
7
        "encoding/json"
 
8
        "fmt"
 
9
        "strings"
 
10
        "testing"
 
11
)
 
12
 
 
13
func TestDataDriversReaderFail(t *testing.T) {
 
14
        r := failReader{}
 
15
 
 
16
        if _, err := ReadDrive(r); err == nil || err.Error() != "test error" {
 
17
                t.Error("Fail")
 
18
        }
 
19
 
 
20
        if _, err := ReadDrives(r); err == nil || err.Error() != "test error" {
 
21
                t.Error("Fail")
 
22
        }
 
23
}
 
24
 
 
25
func TestDataDrivesUnmarshal(t *testing.T) {
 
26
        var dd Drives
 
27
        dd.Meta.Limit = 12345
 
28
        dd.Meta.Offset = 12345
 
29
        dd.Meta.TotalCount = 12345
 
30
        err := json.Unmarshal([]byte(jsonDrivesData), &dd)
 
31
        if err != nil {
 
32
                t.Error(err)
 
33
        }
 
34
 
 
35
        verifyMeta(t, &dd.Meta, 0, 0, 9)
 
36
 
 
37
        for i := 0; i < len(drivesData); i++ {
 
38
                compareDrives(t, i, &dd.Objects[i], &drivesData[i])
 
39
        }
 
40
}
 
41
 
 
42
func TestDataDrivesDetailUnmarshal(t *testing.T) {
 
43
        var dd Drives
 
44
        dd.Meta.Limit = 12345
 
45
        dd.Meta.Offset = 12345
 
46
        dd.Meta.TotalCount = 12345
 
47
        err := json.Unmarshal([]byte(jsonDrivesDetailData), &dd)
 
48
        if err != nil {
 
49
                t.Error(err)
 
50
        }
 
51
 
 
52
        verifyMeta(t, &dd.Meta, 0, 0, 9)
 
53
 
 
54
        for i := 0; i < len(drivesDetailData); i++ {
 
55
                compareDrives(t, i, &dd.Objects[i], &drivesDetailData[i])
 
56
        }
 
57
}
 
58
 
 
59
func TestDataDrivesReadDrives(t *testing.T) {
 
60
        dd, err := ReadDrives(strings.NewReader(jsonDrivesData))
 
61
        if err != nil {
 
62
                t.Error(err)
 
63
        }
 
64
        for i := 0; i < len(drivesData); i++ {
 
65
                compareDrives(t, i, &dd[i], &drivesData[i])
 
66
        }
 
67
}
 
68
 
 
69
func TestDataDrivesReadDrive(t *testing.T) {
 
70
        d, err := ReadDrive(strings.NewReader(jsonDriveData))
 
71
        if err != nil {
 
72
                t.Error(err)
 
73
        }
 
74
 
 
75
        compareDrives(t, 0, d, &driveData)
 
76
}
 
77
 
 
78
func TestDataDrivesLibDrive(t *testing.T) {
 
79
        d, err := ReadDrive(strings.NewReader(jsonLibraryDriveData))
 
80
        if err != nil {
 
81
                t.Error(err)
 
82
        }
 
83
 
 
84
        compareDrives(t, 0, d, &libraryDriveData)
 
85
}
 
86
 
 
87
func compareDrives(t *testing.T, i int, value, wants *Drive) {
 
88
        if value.Resource != wants.Resource {
 
89
                t.Errorf("Drive.Resource error [%d]: found %#v, wants %#v", i, value.Resource, wants.Resource)
 
90
        }
 
91
 
 
92
        if len(value.Affinities) != len(wants.Affinities) {
 
93
                t.Errorf("Drive.Affinities error [%d]: found %#v, wants %#v", i, value.Affinities, wants.Affinities)
 
94
        } else {
 
95
                for j := 0; j < len(value.Affinities); j++ {
 
96
                        v := value.Affinities[j]
 
97
                        w := wants.Affinities[j]
 
98
                        if v != w {
 
99
                                t.Errorf("Drive.Affinities error [%d]: at %d found %#v, wants %#v", i, j, v, w)
 
100
                        }
 
101
                }
 
102
        }
 
103
 
 
104
        if value.AllowMultimount != wants.AllowMultimount {
 
105
                t.Errorf("Drive.AllowMultimount error [%d]: found %#v, wants %#v", i, value.AllowMultimount, wants.AllowMultimount)
 
106
        }
 
107
 
 
108
        if len(value.Jobs) != len(wants.Jobs) {
 
109
                t.Errorf("Drive.Jobs error [%d]: found %#v, wants %#v", i, value.Jobs, wants.Jobs)
 
110
        } else {
 
111
                for j := 0; j < len(value.Jobs); j++ {
 
112
                        v := value.Jobs[j]
 
113
                        w := wants.Jobs[j]
 
114
                        if v != w {
 
115
                                t.Errorf("Drive.Jobs error [%d]: at %d found %#v, wants %#v", i, j, v, w)
 
116
                        }
 
117
                }
 
118
        }
 
119
 
 
120
        if value.Media != wants.Media {
 
121
                t.Errorf("Drive.Media error [%d]: found %#v, wants %#v", i, value.Media, wants.Media)
 
122
        }
 
123
 
 
124
        compareMeta(t, fmt.Sprintf("Drive.Meta error [%d]", i), value.Meta, wants.Meta)
 
125
 
 
126
        if value.Name != wants.Name {
 
127
                t.Errorf("Drive.Name error [%d]: found %#v, wants %#v", i, value.Name, wants.Name)
 
128
        }
 
129
 
 
130
        if value.Owner != nil && wants.Owner != nil {
 
131
                if *value.Owner != *wants.Owner {
 
132
                        t.Errorf("Drive.Owner error [%d]: found %#v, wants %#v", i, value.Owner, wants.Owner)
 
133
                }
 
134
        } else if value.Owner != nil || wants.Owner != nil {
 
135
                t.Errorf("Drive.Owner error [%d]: found %#v, wants %#v", i, value.Owner, wants.Owner)
 
136
        }
 
137
 
 
138
        if value.Size != wants.Size {
 
139
                t.Errorf("Drive.Size error [%d]: found %#v, wants %#v", i, value.Size, wants.Size)
 
140
        }
 
141
 
 
142
        if value.Status != wants.Status {
 
143
                t.Errorf("Drive.Status error [%d]: found %#v, wants %#v", i, value.Status, wants.Status)
 
144
        }
 
145
 
 
146
        if value.StorageType != wants.StorageType {
 
147
                t.Errorf("Drive.StorageType error [%d]: found %#v, wants %#v", i, value.StorageType, wants.StorageType)
 
148
        }
 
149
 
 
150
        //
 
151
        // specific for media library drives
 
152
 
 
153
        if value.Arch != wants.Arch {
 
154
                t.Errorf("Drive.Arch error [%d]: found %#v, wants %#v", i, value.Arch, wants.Arch)
 
155
        }
 
156
        if value.ImageType != wants.ImageType {
 
157
                t.Errorf("Drive.ImageType error [%d]: found %#v, wants %#v", i, value.ImageType, wants.ImageType)
 
158
        }
 
159
        if value.OS != wants.OS {
 
160
                t.Errorf("Drive.OS error [%d]: found %#v, wants %#v", i, value.OS, wants.OS)
 
161
        }
 
162
        if value.Paid != wants.Paid {
 
163
                t.Errorf("Drive.Paid error [%d]: found %#v, wants %#v", i, value.Paid, wants.Paid)
 
164
        }
 
165
}