Skip to content

Commit 9685530

Browse files
mohitsatrmohitsatr
committed
refactor: convert AddressTest from java to kotlin
1 parent 03adbc7 commit 9685530

File tree

1 file changed

+212
-100
lines changed

1 file changed

+212
-100
lines changed

‎mail/common/src/test/java/com/fsck/k9/mail/AddressTest.kt‎

Lines changed: 212 additions & 100 deletions
Original file line numberDiff line numberDiff line change
@@ -1,164 +1,276 @@
1-
package com.fsck.k9.mail;
2-
3-
4-
import net.thunderbird.core.logging.legacy.Log;
5-
import net.thunderbird.core.logging.testing.TestLogger;
6-
import org.junit.Before;
7-
import org.junit.Test;
8-
9-
import static org.junit.Assert.assertEquals;
10-
import static org.junit.Assert.assertFalse;
11-
import static org.junit.Assert.assertNull;
12-
import static org.junit.Assert.assertTrue;
13-
14-
15-
public class AddressTest {
1+
package com.fsck.k9.mail
2+
3+
import assertk.assertThat
4+
import assertk.assertions.isEqualTo
5+
import assertk.assertions.isFalse
6+
import assertk.assertions.isNotEqualTo
7+
import assertk.assertions.isNull
8+
import assertk.assertions.isTrue
9+
import com.fsck.k9.mail.Address.Companion.parse
10+
import com.fsck.k9.mail.Address.Companion.quoteString
11+
import net.thunderbird.core.logging.legacy.Log
12+
import net.thunderbird.core.logging.testing.TestLogger
13+
import org.junit.Before
14+
import org.junit.Test
15+
16+
class AddressTest {
1617

1718
@Before
18-
public void setUp() {
19-
Log.logger = new TestLogger();
19+
fun setUp() {
20+
Log.logger = TestLogger()
2021
}
2122

22-
2323
/**
2424
* test the possibility to parse "From:" fields with no email.
2525
* for example: From: News for Vector Limited - Google Finance
2626
* http://code.google.com/p/k9mail/issues/detail?id=3814
2727
*/
2828
@Test
29-
public void parse_withMissingEmail__shouldSetPersonal() {
30-
Address[] addresses = Address.parse("NAME ONLY");
29+
@Throws(Exception::class)
30+
fun `parse with Missing Email should return empty addresses`() {
31+
// Arrange
32+
val addressList = "NAME ONLY"
33+
34+
// Act
35+
val addresses = parse(addressList)
36+
37+
// Assert
38+
assertThat(addresses.size).isEqualTo(0)
39+
}
40+
41+
@Test
42+
@Throws(Exception::class)
43+
fun `hostname when address without is provided without domain should return null`() {
44+
// Arrange
45+
val nameOnly = "Max"
46+
val domain = "domain.com"
47+
val address = "$nameOnly@$domain"
48+
49+
// Act
50+
val withoutAddress = Address(nameOnly)
51+
val withAddress = Address(address = address, personal = nameOnly)
52+
53+
// Assert
54+
assertThat(withoutAddress.hostname).isNull()
55+
assertThat(withAddress.hostname).isEqualTo(domain)
56+
}
57+
58+
@Test
59+
fun `toString without missing addresses returns empty string`() {
60+
// Arrange
61+
val emptyAddressList = emptyArray<Address>()
62+
val actualAccounts = parse("prettyandsimple@example.com")
63+
64+
// Act
65+
val emptyString = Address.toString(emptyAddressList)
66+
val addresses = Address.toString(actualAccounts)
67+
68+
// Assert
69+
assertThat(emptyString).isEqualTo("")
70+
assertThat(addresses).isNotEqualTo("")
71+
}
3172

32-
assertEquals(0, addresses.length);
73+
@Test
74+
fun `pack with missing addresses returns empty string`() {
75+
// Arrange
76+
val addressList1 = parse("cc1@domain.example, cc2@domain.example")
77+
val addressList2 = parse("Bob <bob@domain.example>, Max <Max@domain.example>")
78+
val addressList3 = parse("NAME ONLY")
79+
80+
// Act
81+
val result1 = Address.pack(addressList1)
82+
val result2 = Address.pack(addressList2)
83+
val result3 = Address.pack(addressList3)
84+
85+
// Assert
86+
assertThat(result1).isNotEqualTo("")
87+
assertThat(result2).isNotEqualTo("")
88+
assertThat(result3).isEqualTo("")
3389
}
3490

3591
/**
3692
* test name + valid email
3793
*/
3894
@Test
39-
public void parse_withValidEmailAndPersonal_shouldSetBoth() {
40-
Address[] addresses = Address.parse("Max Mustermann <maxmuster@mann.com>");
95+
fun `parse valid Email and Personal should set both`() {
96+
// Arrange
97+
val address = "Max Mustermann <maxmuster@mann.com>"
98+
99+
// Act
100+
val addresses = parse(address)
41101

42-
assertEquals(1, addresses.length);
43-
assertEquals("maxmuster@mann.com", addresses[0].getAddress());
44-
assertEquals("Max Mustermann", addresses[0].getPersonal());
102+
// Assert
103+
assertThat(addresses.size).isEqualTo(1)
104+
assertThat(addresses[0].address).isEqualTo("maxmuster@mann.com")
105+
assertThat(addresses[0].personal).isEqualTo("Max Mustermann")
45106
}
46107

47108
@Test
48-
public void parse_withUnusualEmails_shouldSetAddress() {
49-
String[] testEmails = new String [] {
50-
"prettyandsimple@example.com",
51-
"very.common@example.com",
52-
"disposable.style.email.with+symbol@example.com",
53-
"other.email-with-dash@example.com",
54-
//TODO: Handle addresses with quotes
55-
/*
56-
"\"much.more unusual\"@example.com",
57-
"\"very.unusual.@.unusual.com\"@example.com",
58-
//"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com
59-
"\"very.(),:;<>[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com",
60-
"\"()<>[]:,;@\\\\\\\"!#$%&'*+-/=?^_`{}| ~.a\"@example.org",
61-
"\" \"@example.org",
62-
*/
63-
"admin@mailserver1",
64-
"#!$%&'*+-/=?^_`{}|~@example.org",
65-
"example@localhost",
66-
"example@s.solutions",
67-
"user@com",
68-
"user@localserver",
69-
"user@[IPv6:2001:db8::1]"
70-
};
71-
72-
for(String testEmail: testEmails) {
73-
Address[] addresses = Address.parse("Anonymous <"+testEmail+">");
74-
75-
assertEquals(testEmail, 1, addresses.length);
76-
assertEquals(testEmail, testEmail, addresses[0].getAddress());
109+
fun `parse with unusual Emails should set address`() {
110+
// Arrange
111+
val testEmails = arrayOf(
112+
"prettyandsimple@example.com",
113+
"very.common@example.com",
114+
"disposable.style.email.with+symbol@example.com",
115+
"other.email-with-dash@example.com",
116+
// TODO: Handle addresses with quotes
117+
/*
118+
"\"much.more unusual\"@example.com",
119+
"\"very.unusual.@.unusual.com\"@example.com",
120+
//"very.(),:;<>[]\".VERY.\"very@\\ \"very\".unusual"@strange.example.com
121+
"\"very.(),:;<>[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com",
122+
"\"()<>[]:,;@\\\\\\\"!#$%&'*+-/=?^_`{}| ~.a\"@example.org",
123+
"\" \"@example.org",
124+
*/
125+
"admin@mailserver1",
126+
"#!$%&'*+-/=?^_`{}|~@example.org",
127+
"example@localhost",
128+
"example@s.solutions",
129+
"user@com",
130+
"user@localserver",
131+
"user@[IPv6:2001:db8::1]",
132+
)
133+
134+
testEmails.forEach { mail ->
135+
// Act
136+
val addresses = parse("Anonymous <$mail>")
137+
138+
// Assert
139+
assertThat(addresses.size).isEqualTo(1)
140+
assertThat(addresses[0].address).isEqualTo(mail)
77141
}
78142
}
79143

80144
@Test
81-
public void parse_withEncodedPersonal_shouldDecode() {
82-
Address[] addresses = Address.parse(
83-
"=?UTF-8?B?WWFob28h44OA44Kk44Os44Kv44OI44Kq44OV44Kh44O8?= <directoffer-master@mail.yahoo.co.jp>");
145+
fun `parse with encoded Personal should Decode`() {
146+
// Arrange
147+
val address = "=?UTF-8?B?WWFob28h44OA44Kk44Os44Kv44OI44Kq44OV44Kh44O8?= <directoffer-master@mail.yahoo.co.jp>"
84148

85-
assertEquals("Yahoo!ダイレクトオファー", addresses[0].getPersonal());
86-
assertEquals("directoffer-master@mail.yahoo.co.jp", addresses[0].getAddress());
149+
// Act
150+
val addresses = parse(address)
87151

152+
// Assert
153+
assertThat(addresses[0].personal).isEqualTo("Yahoo!ダイレクトオファー")
154+
assertThat(addresses[0].address).isEqualTo("directoffer-master@mail.yahoo.co.jp")
88155
}
89156

90157
@Test
91-
public void parse_withQuotedEncodedPersonal_shouldDecode() {
92-
Address[] addresses = Address.parse(
93-
"\"=?UTF-8?B?WWFob28h44OA44Kk44Os44Kv44OI44Kq44OV44Kh44O8?= \"<directoffer-master@mail.yahoo.co.jp>");
158+
@Suppress("ktlint:standard:max-line-length", "MaxLineLength")
159+
fun `parse with Quoted encoded Personal should decode`() {
160+
// Arrange
161+
val address = "\"=?UTF-8?B?WWFob28h44OA44Kk44Os44Kv44OI44Kq44OV44Kh44O8?=\"<directoffer-master@mail.yahoo.co.jp>"
94162

95-
assertEquals("Yahoo!ダイレクトオファー ", addresses[0].getPersonal());
96-
assertEquals("directoffer-master@mail.yahoo.co.jp", addresses[0].getAddress());
163+
// Act
164+
val addresses = parse(address)
97165

166+
// Assert
167+
assertThat(addresses[0].personal).isEqualTo("Yahoo!ダイレクトオファー")
168+
assertThat(addresses[0].address).isEqualTo("directoffer-master@mail.yahoo.co.jp")
98169
}
99170

100171
/**
101172
* test with multi email addresses
102173
*/
103174
@Test
104-
public void parse_withMultipleEmails_shouldDecodeBoth() {
105-
Address[] addresses = Address.parse("lorem@ipsum.us,mark@twain.com");
106-
assertEquals(2, addresses.length);
107-
assertEquals("lorem@ipsum.us", addresses[0].getAddress());
108-
assertEquals(null, addresses[0].getPersonal());
109-
assertEquals("mark@twain.com", addresses[1].getAddress());
110-
assertEquals(null, addresses[1].getPersonal());
175+
fun `parse with multiple Emails should decode both`() {
176+
// Arrange
177+
val listOfAddresses = "lorem@ipsum.us,mark@twain.com"
178+
179+
// Act
180+
val addresses = parse(listOfAddresses)
181+
182+
// Assert
183+
assertThat(addresses.size).isEqualTo(2)
184+
185+
assertThat(addresses[0].address).isEqualTo("lorem@ipsum.us")
186+
assertThat(addresses[0].personal).isEqualTo(null)
187+
188+
assertThat(addresses[1].address).isEqualTo("mark@twain.com")
189+
assertThat(addresses[1].personal).isEqualTo(null)
111190
}
112191

113192
@Test
114-
public void stringQuotationShouldCorrectlyQuote() {
115-
assertEquals("\"sample\"", Address.quoteString("sample"));
116-
assertEquals("\"\"sample\"\"", Address.quoteString("\"\"sample\"\""));
117-
assertEquals("\"sample\"", Address.quoteString("\"sample\""));
118-
assertEquals("\"sa\"mp\"le\"", Address.quoteString("sa\"mp\"le"));
119-
assertEquals("\"sa\"mp\"le\"", Address.quoteString("\"sa\"mp\"le\""));
120-
assertEquals("\"\"\"", Address.quoteString("\""));
193+
fun `string quotation should correctly Quote`() {
194+
// Arrange
195+
val testStrings = listOf(
196+
"sample" to "\"sample\"",
197+
"\"\"sample\"\"" to "\"\"sample\"\"",
198+
"\"sample\"" to "\"sample\"",
199+
"sa\"mp\"le" to "\"sa\"mp\"le\"",
200+
"\"sa\"mp\"le\"" to "\"sa\"mp\"le\"",
201+
"\"" to "\"\"\"",
202+
)
203+
204+
testStrings.forEach { (input, expected) ->
205+
// Act
206+
val result = quoteString(input)
207+
208+
// Assert
209+
assertThat(result).isEqualTo(expected)
210+
}
121211
}
122212

123213
@Test
124-
public void hashCode_withoutAddress() throws Exception {
125-
Address[] addresses = Address.parse("name only");
214+
fun `hashCode without Address`() {
215+
// Arrange
216+
val address = "name only"
217+
218+
// Act
219+
val addresses = parse(address)
126220

127-
assertEquals(0, addresses.length);
221+
// Assert
222+
assertThat(addresses.size).isEqualTo(0)
128223
}
129224

130225
@Test
131-
public void hashCode_withoutPersonal() throws Exception {
132-
Address address = Address.parse("alice@example.org")[0];
133-
assertNull(address.getPersonal());
226+
fun `hashCode without Personal`() {
227+
// Arrange
228+
val address = "alice@example.org"
134229

135-
address.hashCode();
230+
// Act
231+
val addressList = parse(address)
232+
233+
// Assert
234+
assertThat(addressList[0].personal).isNull()
235+
addressList.hashCode()
136236
}
137237

138238
@Test
139-
public void equals_withoutPersonal_matchesSame() throws Exception {
140-
Address address = Address.parse("alice@example.org")[0];
141-
Address address2 = Address.parse("alice@example.org")[0];
142-
assertNull(address.getPersonal());
239+
fun `equals without Personal matches same`() {
240+
// Arrange
241+
val address = parse("alice@example.org")[0]
242+
val address2: Address = parse("alice@example.org")[0]
143243

144-
boolean result = address.equals(address2);
244+
// Act
245+
val result = address.equals(address2)
145246

146-
assertTrue(result);
247+
// Assert
248+
assertThat(address.personal).isNull()
249+
assertThat(result).isTrue()
147250
}
148251

149252
@Test
150-
public void equals_withoutPersonal_doesNotMatchWithAddress() throws Exception {
151-
Address address = Address.parse("alice@example.org")[0];
152-
Address address2 = Address.parse("Alice <alice@example.org>")[0];
253+
fun `equals without Personal does not match with address`() {
254+
// Arrange
255+
val address = parse("alice@example.org")[0]
256+
val address2: Address = parse("Alice <alice@example.org>")[0]
153257

154-
boolean result = address.equals(address2);
258+
// Act
259+
val result = address.equals(address2)
155260

156-
assertFalse(result);
261+
// Assert
262+
assertThat(result).isFalse()
157263
}
158264

159265
@Test
160-
public void handlesInvalidBase64Encoding() throws Exception {
161-
Address address = Address.parse("=?utf-8?b?invalid#?= <oops@example.com>")[0];
162-
assertEquals("oops@example.com", address.getAddress());
266+
fun `handles invalid Base64Encoding`() {
267+
// Arrange
268+
val base64Encoding = "=?utf-8?b?invalid#?= <oops@example.com>"
269+
270+
// Act
271+
val address = parse(base64Encoding)[0]
272+
273+
// Assert
274+
assertThat(address.address).isEqualTo("oops@example.com")
163275
}
164276
}

0 commit comments

Comments
 (0)