phony 2.19.11 → 2.20.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -4,197 +4,220 @@ describe Phony::CountryCodes do
4
4
 
5
5
  let(:countries) { Phony::CountryCodes.instance }
6
6
 
7
+ describe '#plausible?' do
8
+ it 'raises an error on a too long ccc' do
9
+ expect do
10
+ countries.plausible?('+1 868 7620266', ccc: '1868123')
11
+ end.to raise_error(ArgumentError, %Q{The provided ccc option is too long and includes more than a cc ('1') and ndc ('868'). It also includes '123'.})
12
+ end
13
+ end
14
+
15
+ describe 'ccc handling' do
16
+ it 'splits a ccc correctly' do
17
+ cc, ndc, *local = countries.split('1868')
18
+
19
+ expect(cc).to eq '1'
20
+ expect(ndc).to eq '868'
21
+ end
22
+ it 'splits a ccc correctly' do
23
+ cc, ndc, *local = countries.split('1868')
24
+
25
+ expect(cc).to eq '1'
26
+ expect(ndc).to eq '868'
27
+ end
28
+ end
29
+
7
30
  describe '#[]' do
8
31
  it 'returns a country' do
9
- countries['41'].class.should eql Phony::Country
32
+ expect(countries['41'].class).to eq Phony::Country
10
33
  end
11
34
  end
12
35
 
13
36
  describe '#country_for' do
14
37
  it 'returns a country' do
15
- countries.send(:country_for, '41').class.should eql Phony::Country
38
+ expect(countries.send(:country_for, '41').class).to eq Phony::Country
16
39
  end
17
40
  end
18
41
 
19
42
  describe '#countrify' do
20
43
  it 'returns a country' do
21
- countries.send(:countrify, '441231212', '41').should eql '41441231212'
44
+ expect(countries.send(:countrify, '441231212', '41')).to eq '41441231212'
22
45
  end
23
46
  end
24
47
  describe '#countrify!' do
25
48
  it 'in-place replaces the number' do
26
49
  number = '441231212'
27
- countries.send(:countrify!, number, '41').should eql number
50
+ expect(countries.send(:countrify!, number, '41')).to eq number
28
51
 
29
- number.should == '41441231212'
52
+ expect(number).to eq '41441231212'
30
53
  end
31
54
  end
32
55
 
33
56
  describe '#vanity?' do
34
57
  it 'returns true if so' do
35
- countries.vanity?('1800HELLOES').should eql true
58
+ expect(countries.vanity?('1800HELLOES')).to eq true
36
59
  end
37
60
  it 'returns false if not' do
38
- countries.vanity?('18001234567').should eql false
61
+ expect(countries.vanity?('18001234567')).to eq false
39
62
  end
40
63
  end
41
64
 
42
65
  describe 'normalize' do
43
66
  it 'normalizes correctly' do
44
- countries.normalize('0041-44-364-35-32').should eql '41443643532'
67
+ expect(countries.normalize('0041-44-364-35-32')).to eq '41443643532'
45
68
  end
46
69
  it 'normalizes correctly with CC option' do
47
- countries.normalize('044-364-35-32', cc: '41').should eql '41443643532'
70
+ expect(countries.normalize('044-364-35-32', cc: '41')).to eq '41443643532'
48
71
  end
49
72
 
50
73
  context 'specific countries' do
51
74
  it 'handles Congo correctly' do
52
- countries.normalize('+242 0571 73992').should eql '242057173992'
53
- countries.normalize('+242 2221 15932').should eql '242222115932'
75
+ expect(countries.normalize('+242 0571 73992')).to eq '242057173992'
76
+ expect(countries.normalize('+242 2221 15932')).to eq '242222115932'
54
77
  end
55
78
  end
56
79
  end
57
80
 
58
81
  describe 'formatted' do
59
82
  it 'formats correctly' do
60
- countries.formatted('41443643532', :format => :international, :spaces => :-).should eql '+41-44-364-35-32'
83
+ expect(countries.formatted('41443643532', :format => :international, :spaces => :-)).to eq '+41-44-364-35-32'
61
84
  end
62
85
  it 'formats correctly' do
63
- countries.formatted('41443643532', :format => :international_relative, :spaces => :-).should eql '0041-44-364-35-32'
86
+ expect(countries.formatted('41443643532', :format => :international_relative, :spaces => :-)).to eq '0041-44-364-35-32'
64
87
  end
65
88
  it 'formats correctly' do
66
- countries.formatted('41443643532', :format => :national, :spaces => :-).should eql '044-364-35-32'
89
+ expect(countries.formatted('41443643532', :format => :national, :spaces => :-)).to eq '044-364-35-32'
67
90
  end
68
91
  context 'specific' do
69
92
  it 'formats Ireland correctly' do
70
- countries.formatted("3533451234", :format => :national).should eql '0345 1234'
93
+ expect(countries.formatted("3533451234", :format => :national)).to eq '0345 1234'
71
94
  end
72
95
  it 'formats Ireland correctly' do
73
- countries.formatted("353411231234", :format => :national).should eql '041 123 1234'
96
+ expect(countries.formatted("353411231234", :format => :national)).to eq '041 123 1234'
74
97
  end
75
98
  it 'formats Spain correctly' do
76
- countries.formatted("34123456789", :format => :national).should eql '123 456 789'
99
+ expect(countries.formatted("34123456789", :format => :national)).to eq '123 456 789'
77
100
  end
78
101
  it 'formats Cambodia correctly' do
79
- countries.formatted('85512239123', :format => :national).should eql '012 239 123'
102
+ expect(countries.formatted('85512239123', :format => :national)).to eq '012 239 123'
80
103
  end
81
104
  it 'formats the US correctly' do
82
- countries.formatted('18005551212', :format => :national, :spaces => :-).should eql '(800)-555-1212'
105
+ expect(countries.formatted('18005551212', :format => :national, :spaces => :-)).to eq '(800)-555-1212'
83
106
  end
84
107
  it 'formats the US correctly' do
85
- countries.formatted('18005551212', :format => :national, :spaces => :-).should eql '(800)-555-1212'
108
+ expect(countries.formatted('18005551212', :format => :national, :spaces => :-)).to eq '(800)-555-1212'
86
109
  end
87
110
  end
88
111
  context 'default' do
89
112
  it "should format swiss numbers" do
90
- countries.formatted('41443643532').should eql '+41 44 364 35 32'
113
+ expect(countries.formatted('41443643532')).to eq '+41 44 364 35 32'
91
114
  end
92
115
  it "should format swiss service numbers" do
93
- countries.formatted('41800112233').should eql '+41 800 112 233'
116
+ expect(countries.formatted('41800112233')).to eq '+41 800 112 233'
94
117
  end
95
118
  it "should format austrian numbers" do
96
- countries.formatted('43198110').should eql '+43 1 98110'
119
+ expect(countries.formatted('43198110')).to eq '+43 1 98110'
97
120
  end
98
121
  it "should format american numbers" do
99
- countries.formatted('18705551122').should eql '+1 (870) 555-1122'
122
+ expect(countries.formatted('18705551122')).to eq '+1 (870) 555-1122'
100
123
  end
101
124
  it "should format irish numbers" do
102
- countries.formatted('35311234567').should eql '+353 1 123 4567'
125
+ expect(countries.formatted('35311234567')).to eq '+353 1 123 4567'
103
126
  end
104
127
  end
105
128
  describe "international" do
106
129
  it "should format north american numbers" do
107
- countries.formatted('18091231234', :format => :international).should eql '+1 (809) 123-1234'
130
+ expect(countries.formatted('18091231234', :format => :international)).to eq '+1 (809) 123-1234'
108
131
  end
109
132
  it "should format austrian numbers" do
110
- countries.formatted('43198110', :format => :international).should eql '+43 1 98110'
133
+ expect(countries.formatted('43198110', :format => :international)).to eq '+43 1 98110'
111
134
  end
112
135
  it "should format austrian numbers" do
113
- countries.formatted('43198110', :format => :international_absolute).should eql '+43 1 98110'
136
+ expect(countries.formatted('43198110', :format => :international_absolute)).to eq '+43 1 98110'
114
137
  end
115
138
  it "should format french numbers" do
116
- countries.formatted('33142278186', :format => :+).should eql '+33 1 42 27 81 86'
139
+ expect(countries.formatted('33142278186', :format => :+)).to eq '+33 1 42 27 81 86'
117
140
  end
118
141
  it "should format austrian numbers" do
119
- countries.formatted('43198110', :format => :international_relative).should eql '0043 1 98110'
142
+ expect(countries.formatted('43198110', :format => :international_relative)).to eq '0043 1 98110'
120
143
  end
121
144
  it 'should format liechtensteiner numbers' do
122
- countries.formatted('4233841148', :format => :international_relative).should eql '00423 384 11 48'
145
+ expect(countries.formatted('4233841148', :format => :international_relative)).to eq '00423 384 11 48'
123
146
  end
124
147
  it "should format irish numbers" do
125
- countries.formatted('35311234567', :format => :international).should eql '+353 1 123 4567'
148
+ expect(countries.formatted('35311234567', :format => :international)).to eq '+353 1 123 4567'
126
149
  end
127
150
  it "should format luxembourgian numbers" do
128
- countries.formatted('352222809', :format => :international).should eql '+352 22 28 09'
151
+ expect(countries.formatted('352222809', :format => :international)).to eq '+352 22 28 09'
129
152
  end
130
153
  it "should format luxembourgian 4-digit ndc numbers" do
131
- countries.formatted('35226222809', :format => :international).should eql '+352 2622 28 09'
154
+ expect(countries.formatted('35226222809', :format => :international)).to eq '+352 2622 28 09'
132
155
  end
133
156
  it "should format luxembourgian mobile numbers" do
134
- countries.formatted('352621123456', :format => :international).should eql '+352 621 123 456'
157
+ expect(countries.formatted('352621123456', :format => :international)).to eq '+352 621 123 456'
135
158
  end
136
159
  it "should format luxembourgian city numbers" do
137
- countries.formatted('3524123456', :format => :international).should eql '+352 41 23 45 6'
160
+ expect(countries.formatted('3524123456', :format => :international)).to eq '+352 41 23 45 6'
138
161
  end
139
162
  it "should format luxembourgian machine to machine numbers" do
140
- countries.formatted('352602112345678', :format => :international).should eql '+352 6021 12 34 56 78'
163
+ expect(countries.formatted('352602112345678', :format => :international)).to eq '+352 6021 12 34 56 78'
141
164
  end
142
165
  it "should format luxembourgian numbers" do
143
- countries.formatted('352370431', :format => :international).should eql '+352 37 04 31'
166
+ expect(countries.formatted('352370431', :format => :international)).to eq '+352 37 04 31'
144
167
  end
145
168
  it "should format luxembourgian numbers" do
146
- countries.formatted('35227855', :format => :international).should eql '+352 27 85 5'
169
+ expect(countries.formatted('35227855', :format => :international)).to eq '+352 27 85 5'
147
170
  end
148
171
  it "should format nigerian lagosian numbers" do
149
- countries.formatted('23414480000', :format => :international).should eql '+234 1 448 0000'
172
+ expect(countries.formatted('23414480000', :format => :international)).to eq '+234 1 448 0000'
150
173
  end
151
174
  it "should format nigerian beninese numbers" do
152
- countries.formatted('23452123456', :format => :international).should eql '+234 52 123 456'
175
+ expect(countries.formatted('23452123456', :format => :international)).to eq '+234 52 123 456'
153
176
  end
154
177
  it "should format nigerian mobile numbers" do
155
- countries.formatted('2347061234567', :format => :international).should eql '+234 706 123 4567'
178
+ expect(countries.formatted('2347061234567', :format => :international)).to eq '+234 706 123 4567'
156
179
  end
157
180
  context 'with no spaces' do
158
181
  it "should format north american numbers" do
159
- Phony.formatted('18091231234', :format => :international, :spaces => '').should eql '+1(809)123-1234'
182
+ expect(Phony.formatted('18091231234', :format => :international, :spaces => '')).to eq '+1(809)123-1234'
160
183
  end
161
184
  it "should format austrian numbers" do
162
- Phony.formatted('43198110', :format => :international, :spaces => '').should eql '+43198110'
185
+ expect(Phony.formatted('43198110', :format => :international, :spaces => '')).to eq '+43198110'
163
186
  end
164
187
  it "should format austrian numbers" do
165
- Phony.formatted('43198110', :format => :international_absolute, :spaces => '').should eql '+43198110'
188
+ expect(Phony.formatted('43198110', :format => :international_absolute, :spaces => '')).to eq '+43198110'
166
189
  end
167
190
  it "should format french numbers" do
168
- Phony.formatted('33142278186', :format => :+, :spaces => '').should eql '+33142278186'
191
+ expect(Phony.formatted('33142278186', :format => :+, :spaces => '')).to eq '+33142278186'
169
192
  end
170
193
  it "should format austrian numbers" do
171
- Phony.formatted('43198110', :format => :international_relative, :spaces => '').should eql '0043198110'
194
+ expect(Phony.formatted('43198110', :format => :international_relative, :spaces => '')).to eq '0043198110'
172
195
  end
173
196
  it 'should format liechtensteiner numbers' do
174
- Phony.formatted('4233841148', :format => :international_relative, :spaces => '').should eql '004233841148'
197
+ expect(Phony.formatted('4233841148', :format => :international_relative, :spaces => '')).to eq '004233841148'
175
198
  end
176
199
  end
177
200
  context 'with special spaces' do
178
201
  it "should format swiss numbers" do
179
- Phony.formatted('41443643532', :format => :international).should eql '+41 44 364 35 32'
202
+ expect(Phony.formatted('41443643532', :format => :international)).to eq '+41 44 364 35 32'
180
203
  end
181
204
  it "should format north american numbers" do
182
- Phony.formatted('18091231234', :format => :international, :spaces => :-).should eql '+1-(809)-123-1234'
205
+ expect(Phony.formatted('18091231234', :format => :international, :spaces => :-)).to eq '+1-(809)-123-1234'
183
206
  end
184
207
  it "should format austrian numbers" do
185
- Phony.formatted('43198110', :format => :international, :spaces => :-).should eql '+43-1-98110'
208
+ expect(Phony.formatted('43198110', :format => :international, :spaces => :-)).to eq '+43-1-98110'
186
209
  end
187
210
  it "should format austrian numbers" do
188
- Phony.formatted('43198110', :format => :international_absolute, :spaces => :-).should eql '+43-1-98110'
211
+ expect(Phony.formatted('43198110', :format => :international_absolute, :spaces => :-)).to eq '+43-1-98110'
189
212
  end
190
213
  it "should format french numbers" do
191
- Phony.formatted('33142278186', :format => :+, :spaces => :-).should eql '+33-1-42-27-81-86'
214
+ expect(Phony.formatted('33142278186', :format => :+, :spaces => :-)).to eq '+33-1-42-27-81-86'
192
215
  end
193
216
  it "should format austrian numbers" do
194
- Phony.formatted('43198110', :format => :international_relative, :spaces => :-).should eql '0043-1-98110'
217
+ expect(Phony.formatted('43198110', :format => :international_relative, :spaces => :-)).to eq '0043-1-98110'
195
218
  end
196
219
  it 'should format liechtensteiner numbers' do
197
- Phony.formatted('4233841148', :format => :international_relative, :spaces => :-).should eql '00423-384-11-48'
220
+ expect(Phony.formatted('4233841148', :format => :international_relative, :spaces => :-)).to eq '00423-384-11-48'
198
221
  end
199
222
 
200
223
  end
@@ -12,12 +12,12 @@ describe Phony::Country do
12
12
  end
13
13
  describe '#clean' do
14
14
  it 'cleans the number' do
15
- country.clean('+41-44-123-12-12').should eql '41441231212'
15
+ expect(country.clean('+41-44-123-12-12')).to eq '41441231212'
16
16
  end
17
17
  end
18
18
  describe '#vanity_to_number' do
19
19
  it 'turns the vanity number into a number' do
20
- country.vanity_to_number('1-800-HELLO').should eql '1-800-43556'
20
+ expect(country.vanity_to_number('1-800-HELLO')).to eq '1-800-43556'
21
21
  end
22
22
  end
23
23
  end
@@ -32,27 +32,27 @@ describe Phony::Country do
32
32
  described_class.new national_code
33
33
  end
34
34
  it 'splits correctly' do
35
- country.split('112').should == [nil, false, '112']
35
+ expect(country.split('112')).to eq [nil, false, '112']
36
36
  end
37
37
  end
38
38
  describe 'San Marino' do
39
39
  it 'normalizes correctly' do
40
- Phony.normalize('+3780549903549').should == '3780549903549'
40
+ expect(Phony.normalize('+3780549903549')).to eq '3780549903549'
41
41
  end
42
42
  xit 'automatically adds the sole NC' do
43
- Phony.normalize('+378903549').should == '3780549903549'
43
+ expect(Phony.normalize('+378903549')).to eq '3780549903549'
44
44
  end
45
45
  end
46
46
  describe 'Japan' do
47
47
  it 'normalizes correctly' do
48
- Phony.normalize('+81-03-1234-5634').should == '81312345634'
49
- Phony.normalize('03-1234-5634', cc: '81').should == '81312345634'
48
+ expect(Phony.normalize('+81-03-1234-5634')).to eq '81312345634'
49
+ expect(Phony.normalize('03-1234-5634', cc: '81')).to eq '81312345634'
50
50
  end
51
51
  it 'formats correctly' do
52
- Phony.format('81312345634').should == '+81-3-1234-5634'
52
+ expect(Phony.format('81312345634')).to eq '+81-3-1234-5634'
53
53
  end
54
54
  it 'splits correctly' do
55
- Phony.split('81312345634').should == %w(81 3 1234 5634)
55
+ expect(Phony.split('81312345634')).to eq %w(81 3 1234 5634)
56
56
  end
57
57
  end
58
58
  end
@@ -68,12 +68,12 @@ describe Phony::Country do
68
68
 
69
69
  describe "split" do
70
70
  it "should handle ZH" do
71
- country.split('443643532').should == [nil, '44', '364', '35', '32']
71
+ expect(country.split('443643532')).to eq [nil, '44', '364', '35', '32']
72
72
  end
73
73
  end
74
74
  describe 'normalize' do
75
75
  it "should handle ZH" do
76
- country.normalize('0443643532').should == '443643532'
76
+ expect(country.normalize('0443643532')).to eq '443643532'
77
77
  end
78
78
  end
79
79
  end
@@ -93,10 +93,10 @@ describe Phony::Country do
93
93
 
94
94
  describe "split" do
95
95
  it "should handle ZH" do
96
- country.split('443643532').should == [nil, '44', '364', '35', '32']
96
+ expect(country.split('443643532')).to eq [nil, '44', '364', '35', '32']
97
97
  end
98
98
  it "should handle 800" do
99
- country.split('800333666').should == [nil, '800', '333', '666']
99
+ expect(country.split('800333666')).to eq [nil, '800', '333', '666']
100
100
  end
101
101
  end
102
102
  end
@@ -7,9 +7,13 @@ describe Phony::DSL do
7
7
  let(:dsl) { described_class.new }
8
8
 
9
9
  it 'has a todo' do
10
+ result = nil
11
+
10
12
  Phony.define do
11
- todo.split("123456789012345").should == [nil, false, '123456789012345']
13
+ result = todo.split("123456789012345")
12
14
  end
15
+
16
+ expect(result).to eq [nil, false, '123456789012345']
13
17
  end
14
18
 
15
19
  describe 'match' do
@@ -17,7 +21,7 @@ describe Phony::DSL do
17
21
  expect { dsl.match(/123/) }.to raise_error("Regexp /123/ needs a group in it that defines which digits belong to the NDC.")
18
22
  end
19
23
  it 'should return a Phony::NationalSplitters::Regex' do
20
- dsl.match(/(123)/).class.name.should == Phony::NationalSplitters::Regex.name
24
+ expect(dsl.match(/(123)/).class.name).to eq Phony::NationalSplitters::Regex.name
21
25
  end
22
26
  end
23
27
 
@@ -16,40 +16,37 @@ describe Phony::LocalSplitters::Regex do
16
16
  end
17
17
 
18
18
  describe 'split' do
19
- before(:each) do
20
- # Norway as example.
21
- #
22
- @splitter = described_class.instance_for(/^[489].*$/ => [3,2,3], :fallback => [2,2,2,2])
23
- end
19
+ # Norway.
20
+ let(:splitter) { described_class.instance_for(/^[489].*$/ => [3,2,3], :fallback => [2,2,2,2]) }
24
21
  it 'splits a number correctly' do
25
- @splitter.split('21234567').should == ['21','23','45','67']
22
+ expect(splitter.split('21234567')).to eq ['21','23','45','67']
26
23
  end
27
24
  it 'splits a number correctly' do
28
- @splitter.split('31234567').should == ['31','23','45','67']
25
+ expect(splitter.split('31234567')).to eq ['31','23','45','67']
29
26
  end
30
27
  it 'splits a number correctly' do
31
- @splitter.split('41234567').should == ['412','34','567']
28
+ expect(splitter.split('41234567')).to eq ['412','34','567']
32
29
  end
33
30
  it 'splits a number correctly' do
34
- @splitter.split('51234567').should == ['51','23','45','67']
31
+ expect(splitter.split('51234567')).to eq ['51','23','45','67']
35
32
  end
36
33
  it 'splits a number correctly' do
37
- @splitter.split('61234567').should == ['61','23','45','67']
34
+ expect(splitter.split('61234567')).to eq ['61','23','45','67']
38
35
  end
39
36
  it 'splits a number correctly' do
40
- @splitter.split('71234567').should == ['71','23','45','67']
37
+ expect(splitter.split('71234567')).to eq ['71','23','45','67']
41
38
  end
42
39
  it 'splits a number correctly' do
43
- @splitter.split('81234567').should == ['812','34','567']
40
+ expect(splitter.split('81234567')).to eq ['812','34','567']
44
41
  end
45
42
  it 'splits a number correctly' do
46
- @splitter.split('91234567').should == ['912','34','567']
43
+ expect(splitter.split('91234567')).to eq ['912','34','567']
47
44
  end
48
45
  it 'splits it fast' do
49
- performance_of { @splitter.split('21234567').should == ['21','23','45','67'] }.should < 0.00005
46
+ expect(performance_of { splitter.split('21234567') }).to be < 0.00005
50
47
  end
51
48
  it 'splits it fast' do
52
- performance_of { @splitter.split('91234567').should == ['912','34','567'] }.should < 0.00004
49
+ expect(performance_of { splitter.split('91234567') }).to be < 0.00004
53
50
  end
54
51
  end
55
52
 
@@ -5,87 +5,57 @@ describe Phony::NationalCode do
5
5
  describe 'split' do
6
6
  context 'regression' do
7
7
  describe 'iceland' do
8
- before(:each) do
8
+ let(:national) do
9
9
  national_splitter = Phony::NationalSplitters::None.instance_for
10
10
  local_splitter = Phony::LocalSplitters::Fixed.instance_for [3, 4]
11
11
 
12
- @national = Phony::NationalCode.new national_splitter, local_splitter
12
+ Phony::NationalCode.new national_splitter, local_splitter
13
13
  end
14
14
  it 'splits correctly' do
15
- @national.split('112').should == [nil, false, '112']
15
+ expect(national.split('112')).to eq [nil, false, '112']
16
16
  end
17
17
  end
18
18
  end
19
19
  context 'with fixed ndc (Swiss)' do
20
- before(:each) do
20
+ let(:national) do
21
21
  national_splitter = Phony::NationalSplitters::Fixed.instance_for 2
22
22
  local_splitter = Phony::LocalSplitters::Fixed.instance_for [3, 2, 2]
23
23
 
24
- @national = Phony::NationalCode.new national_splitter, local_splitter
24
+ Phony::NationalCode.new national_splitter, local_splitter
25
25
  end
26
26
  it 'splits correctly' do
27
- @national.split('443643532').should == [nil, '44', '364', '35', '32']
27
+ expect(national.split('443643532')).to eq [nil, '44', '364', '35', '32']
28
28
  end
29
29
  it 'splits correctly' do
30
- @national.split('44364353').should == [nil, '44', '364', '35', '3']
30
+ expect(national.split('44364353')).to eq [nil, '44', '364', '35', '3']
31
31
  end
32
32
  it 'normalizes correctly' do
33
- @national.normalize('044364353').should == '44364353'
33
+ expect(national.normalize('044364353')).to eq '44364353'
34
34
  end
35
35
  it 'normalizes correctly' do
36
- @national.normalize('44364353').should == '44364353'
36
+ expect(national.normalize('44364353')).to eq '44364353'
37
37
  end
38
38
  end
39
39
  context 'with fixed ndc (French)' do
40
- before(:each) do
40
+ let(:national) do
41
41
  national_splitter = Phony::NationalSplitters::Fixed.instance_for 1
42
42
  local_splitter = Phony::LocalSplitters::Fixed.instance_for [2, 2, 2, 2]
43
43
 
44
- @national = Phony::NationalCode.new national_splitter, local_splitter
44
+ Phony::NationalCode.new national_splitter, local_splitter
45
45
  end
46
46
  it 'splits correctly' do
47
- @national.split('142278186').should == [nil, '1', '42', '27', '81', '86']
47
+ expect(national.split('142278186')).to eq [nil, '1', '42', '27', '81', '86']
48
48
  end
49
49
  it 'splits correctly' do
50
- @national.split('14227818').should == [nil, '1', '42', '27', '81', '8']
50
+ expect(national.split('14227818')).to eq [nil, '1', '42', '27', '81', '8']
51
51
  end
52
52
  it 'normalizes correctly' do
53
- @national.normalize('0142278186').should == '142278186'
53
+ expect(national.normalize('0142278186')).to eq '142278186'
54
54
  end
55
55
  it 'normalizes correctly' do
56
- @national.normalize('142278186').should == '142278186'
56
+ expect(national.normalize('142278186')).to eq '142278186'
57
57
  end
58
58
  end
59
- # context 'normalizing' do
60
- # context 'false' do
61
- # before(:each) do
62
- # @national = Phony::NationalCode.new nil, nil, false
63
- # end
64
- # it 'normalizes an italian case correctly' do
65
- # @national.normalize('0909709511').should == '0909709511'
66
- # end
67
- # end
68
- # context 'true' do
69
- # before(:each) do
70
- # national_splitter = Phony::NationalSplitters::Fixed.instance_for 2
71
- # local_splitter = Phony::LocalSplitters::Fixed.instance_for [3, 2, 2]
72
- # @national = Phony::NationalCode.new national_splitter, local_splitter, true
73
- # end
74
- # it 'normalizes a swiss case correctly' do
75
- # @national.normalize('044364353').should == '44364353'
76
- # end
77
- # end
78
- # context 'nil (true)' do
79
- # before(:each) do
80
- # national_splitter = Phony::NationalSplitters::Fixed.instance_for 2
81
- # local_splitter = Phony::LocalSplitters::Fixed.instance_for [3, 2, 2]
82
- # @national = Phony::NationalCode.new national_splitter, local_splitter, nil
83
- # end
84
- # it 'normalizes a swiss case correctly' do
85
- # @national.normalize('044364353').should == '44364353'
86
- # end
87
- # end
88
- # end
89
59
  end
90
60
 
91
61
  end
@@ -4,45 +4,41 @@ describe Phony::NationalSplitters::Fixed do
4
4
 
5
5
  describe 'instance_for' do
6
6
  it 'caches' do
7
- Phony::NationalSplitters::Fixed.instance_for(3).should equal(Phony::NationalSplitters::Fixed.instance_for(3))
7
+ expect(Phony::NationalSplitters::Fixed.instance_for(3)).to eq Phony::NationalSplitters::Fixed.instance_for(3)
8
8
  end
9
9
  it 'caches correctly' do
10
- Phony::NationalSplitters::Fixed.instance_for(1).should_not equal(Phony::NationalSplitters::Fixed.instance_for(2))
10
+ expect(Phony::NationalSplitters::Fixed.instance_for(1)).to_not eq Phony::NationalSplitters::Fixed.instance_for(2)
11
11
  end
12
12
  end
13
13
 
14
14
  describe 'split' do
15
- before(:each) do
16
- @splitter = Phony::NationalSplitters::Fixed.new 2
17
- end
15
+ let(:splitter) { Phony::NationalSplitters::Fixed.new(2) }
18
16
  it 'splits correctly' do
19
- @splitter.split('443643532').should == [nil, '44', '3643532']
17
+ expect(splitter.split('443643532')).to eq [nil, '44', '3643532']
20
18
  end
21
19
  it 'splits correctly even when the number is too long' do
22
- @splitter.split('44364353211').should == [nil, '44', '364353211']
20
+ expect(splitter.split('44364353211')).to eq [nil, '44', '364353211']
23
21
  end
24
22
  it 'splits correctly even when the number is too short' do
25
- @splitter.split('443').should == [nil, '44','3']
23
+ expect(splitter.split('443')).to eq [nil, '44','3']
26
24
  end
27
25
  it 'has a length of 2' do
28
- @splitter.length.should == 2
26
+ expect(splitter.length).to eq 2
29
27
  end
30
28
  end
31
29
  describe 'split' do
32
- before(:each) do
33
- @splitter = Phony::NationalSplitters::Fixed.new nil
34
- end
30
+ let(:splitter) { Phony::NationalSplitters::Fixed.new(nil) }
35
31
  it 'splits correctly' do
36
- @splitter.split('443643532').should == [nil, '443643532']
32
+ expect(splitter.split('443643532')).to eq [nil, '443643532']
37
33
  end
38
34
  it 'splits correctly even when the number is too long' do
39
- @splitter.split('44364353211').should == [nil, '44364353211']
35
+ expect(splitter.split('44364353211')).to eq [nil, '44364353211']
40
36
  end
41
37
  it 'splits correctly even when the number is too short' do
42
- @splitter.split('443').should == [nil, '443']
38
+ expect(splitter.split('443')).to eq [nil, '443']
43
39
  end
44
40
  it 'has a length of nil' do
45
- @splitter.length.should == nil
41
+ expect(splitter.length).to eq nil
46
42
  end
47
43
  end
48
44
 
@@ -4,7 +4,7 @@ describe Phony::NationalSplitters::None do
4
4
 
5
5
  describe 'instance_for' do
6
6
  it 'caches' do
7
- described_class.instance_for.should equal(described_class.instance_for)
7
+ expect(described_class.instance_for).to eq described_class.instance_for
8
8
  end
9
9
  end
10
10
 
@@ -13,13 +13,13 @@ describe Phony::NationalSplitters::None do
13
13
 
14
14
  describe 'split' do
15
15
  it 'splits correctly into ndc and rest' do
16
- splitter.split('123456789').should == [nil, false, '123456789']
16
+ expect(splitter.split('123456789')).to eq [nil, false, '123456789']
17
17
  end
18
18
  end
19
19
 
20
20
  describe 'length' do
21
21
  it 'is always 0' do
22
- splitter.length.should be_zero
22
+ expect(splitter.length).to be_zero
23
23
  end
24
24
  end
25
25