← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/Azure/azure-sdk-for-go/Godeps/_workspace/src/github.com/Azure/go-autorest/autorest/error_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/Azure/azure-sdk-for-go/Godeps/_workspace/src/github.com/Azure/go-autorest/autorest/error_test.go
 
1
package autorest
 
2
 
 
3
import (
 
4
        "fmt"
 
5
        "reflect"
 
6
        "regexp"
 
7
        "testing"
 
8
)
 
9
 
 
10
func TestNewErrorWithErrorAssignsPackageType(t *testing.T) {
 
11
        e := NewErrorWithError(fmt.Errorf("original"), "packageType", "method", "message")
 
12
 
 
13
        if e.PackageType() != "packageType" {
 
14
                t.Errorf("autorest: Error failed to set package type -- expected %v, received %v", "packageType", e.PackageType())
 
15
        }
 
16
}
 
17
 
 
18
func TestNewErrorWithErrorAssignsMethod(t *testing.T) {
 
19
        e := NewErrorWithError(fmt.Errorf("original"), "packageType", "method", "message")
 
20
 
 
21
        if e.Method() != "method" {
 
22
                t.Errorf("autorest: Error failed to set package type -- expected %v, received %v", "method", e.Method())
 
23
        }
 
24
}
 
25
 
 
26
func TestNewErrorWithErrorAssignsMessage(t *testing.T) {
 
27
        e := NewErrorWithError(fmt.Errorf("original"), "packageType", "method", "message")
 
28
 
 
29
        if e.Message() != "message" {
 
30
                t.Errorf("autorest: Error failed to set package type -- expected %v, received %v", "message", e.Message())
 
31
        }
 
32
}
 
33
 
 
34
func TestNewErrorWithErrorAcceptsArgs(t *testing.T) {
 
35
        e := NewErrorWithError(fmt.Errorf("original"), "packageType", "method", "message %s", "arg")
 
36
 
 
37
        if matched, _ := regexp.MatchString(`.*arg.*`, e.Message()); !matched {
 
38
                t.Errorf("autorest: Error failed to apply message arguments -- expected %v, received %v",
 
39
                        `.*arg.*`, e.Message())
 
40
        }
 
41
}
 
42
 
 
43
func TestNewErrorWithErrorAssignsError(t *testing.T) {
 
44
        err := fmt.Errorf("original")
 
45
        e := NewErrorWithError(err, "packageType", "method", "message")
 
46
 
 
47
        if e.Original() != err {
 
48
                t.Errorf("autorest: Error failed to set package type -- expected %v, received %v", err, e.Original())
 
49
        }
 
50
}
 
51
 
 
52
func TestNewErrorForwards(t *testing.T) {
 
53
        e1 := NewError("packageType", "method", "message %s", "arg")
 
54
        e2 := NewErrorWithError(nil, "packageType", "method", "message %s", "arg")
 
55
 
 
56
        if !reflect.DeepEqual(e1, e2) {
 
57
                t.Error("autorest: NewError did not return an error equivelent to NewErrorWithError")
 
58
        }
 
59
}
 
60
 
 
61
func TestErrorError(t *testing.T) {
 
62
        err := fmt.Errorf("original")
 
63
        e := NewErrorWithError(err, "packageType", "method", "message")
 
64
 
 
65
        if matched, _ := regexp.MatchString(`.*original.*`, e.Error()); !matched {
 
66
                t.Errorf("autorest: Error#Error failed to return original error message -- expected %v, received %v",
 
67
                        `.*original.*`, e.Error())
 
68
        }
 
69
}
 
70
 
 
71
func TestErrorStringConstainsPackageType(t *testing.T) {
 
72
        e := NewErrorWithError(fmt.Errorf("original"), "packageType", "method", "message")
 
73
 
 
74
        if matched, _ := regexp.MatchString(`.*packageType.*`, e.String()); !matched {
 
75
                t.Errorf("autorest: Error#String failed to include PackageType -- expected %v, received %v",
 
76
                        `.*packageType.*`, e.String())
 
77
        }
 
78
}
 
79
 
 
80
func TestErrorStringConstainsMethod(t *testing.T) {
 
81
        e := NewErrorWithError(fmt.Errorf("original"), "packageType", "method", "message")
 
82
 
 
83
        if matched, _ := regexp.MatchString(`.*method.*`, e.String()); !matched {
 
84
                t.Errorf("autorest: Error#String failed to include Method -- expected %v, received %v",
 
85
                        `.*method.*`, e.String())
 
86
        }
 
87
}
 
88
 
 
89
func TestErrorStringConstainsMessage(t *testing.T) {
 
90
        e := NewErrorWithError(fmt.Errorf("original"), "packageType", "method", "message")
 
91
 
 
92
        if matched, _ := regexp.MatchString(`.*message.*`, e.String()); !matched {
 
93
                t.Errorf("autorest: Error#String failed to include Message -- expected %v, received %v",
 
94
                        `.*message.*`, e.String())
 
95
        }
 
96
}
 
97
 
 
98
func TestErrorStringConstainsOriginal(t *testing.T) {
 
99
        e := NewErrorWithError(fmt.Errorf("original"), "packageType", "method", "message")
 
100
 
 
101
        if matched, _ := regexp.MatchString(`.*original.*`, e.String()); !matched {
 
102
                t.Errorf("autorest: Error#String failed to include Original error -- expected %v, received %v",
 
103
                        `.*original.*`, e.String())
 
104
        }
 
105
}
 
106
 
 
107
func TestErrorStringSkipsOriginal(t *testing.T) {
 
108
        e := NewError("packageType", "method", "message")
 
109
 
 
110
        if matched, _ := regexp.MatchString(`.*Original.*`, e.String()); matched {
 
111
                t.Errorf("autorest: Error#String included missing Original error -- unexpected %v, received %v",
 
112
                        `.*Original.*`, e.String())
 
113
        }
 
114
}