Skip to content

Remove test duplication #2494

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Mar 10, 2021
Merged

Remove test duplication #2494

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
49479ce
Remove test duplication
schmidt-sebastian Mar 10, 2021
1d5a5a4
Add @Test
schmidt-sebastian Mar 10, 2021
327c3bf
Update ObjectValueTest.java
schmidt-sebastian Mar 10, 2021
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
208 changes: 0 additions & 208 deletions ...e-firestore/src/test/java/com/google/firebase/firestore/model/MutableObjectValueTest.java
View file
Open in desktop

This file was deleted.

132 changes: 125 additions & 7 deletions ...ebase/firestore/model/FieldValueTest.java → ...base/firestore/model/ObjectValueTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,8 @@
import static org.junit.Assert.assertNull;

import com.google.firebase.firestore.model.mutation.FieldMask;
import com.google.firestore.v1.MapValue;
import com.google.firestore.v1.Value;
import java.util.Map;
import org.junit.Test;
import org.junit.runner.RunWith;
Expand All @@ -32,7 +34,19 @@

@RunWith(RobolectricTestRunner.class)
@Config(manifest = Config.NONE)
public class FieldValueTest {
public class ObjectValueTest {

private String fooString = "foo";
private Value fooValue = wrap(fooString);
private String barString = "bar";
private Value barValue = wrap(barString);
private Value emptyObject = Value.newBuilder().setMapValue(MapValue.getDefaultInstance()).build();

@Test
public void testSupportsEmptyObjectValues() {
ObjectValue objectValue = new ObjectValue();
assertEquals(new ObjectValue(), objectValue);
}

@Test
public void testExtractsFields() {
Expand Down Expand Up @@ -69,6 +83,36 @@ public void testOverwritesExistingFields() {
assertEquals(wrapObject("a", "mod"), objectValue);
}

@Test
public void testOverwritesNestedFields() {
ObjectValue objectValue = wrapObject("a", map("b", fooString, "c", map("d", fooString)));
objectValue.set(field("a.b"), barValue);
objectValue.set(field("a.c.d"), barValue);
assertEquals(wrapObject("a", map("b", barString, "c", map("d", barString))), objectValue);
}

@Test
public void testOverwritesDeeplyNestedField() {
ObjectValue objectValue = wrapObject("a", map("b", fooString));
objectValue.set(field("a.b.c"), barValue);
assertEquals(wrapObject("a", map("b", map("c", barString))), objectValue);
}

@Test
public void testOverwritesNestedObject() {
ObjectValue objectValue = wrapObject("a", map("b", map("c", fooString, "d", fooString)));
objectValue.set(field("a.b"), barValue);
assertEquals(wrapObject("a", map("b", "bar")), objectValue);
}

@Test
public void testReplacesNestedObject() {
ObjectValue singleValueObject = wrapObject(map("c", barString));
ObjectValue objectValue = wrapObject("a", map("b", fooString));
objectValue.set(field("a"), singleValueObject.get(FieldPath.EMPTY_PATH));
assertEquals(wrapObject("a", map("c", barString)), objectValue);
}

@Test
public void testAddsNewFields() {
ObjectValue objectValue = new ObjectValue();
Expand All @@ -90,6 +134,54 @@ public void testAddsMultipleNewFields() {
assertEquals(wrapObject("a", "a", "b", "b", "c", "c"), object);
}

@Test
public void testAddsNestedField() {
ObjectValue objectValue = new ObjectValue();
objectValue.set(field("a.b"), fooValue);
objectValue.set(field("c.d.e"), fooValue);
assertEquals(
wrapObject("a", map("b", fooString), "c", map("d", map("e", fooString))), objectValue);
}

@Test
public void testAddsFieldInNestedObject() {
ObjectValue objectValue = new ObjectValue();
objectValue.set(field("a"), wrapObject("b", fooString).get(FieldPath.EMPTY_PATH));
objectValue.set(field("a.c"), fooValue);
assertEquals(wrapObject("a", map("b", fooString, "c", fooString)), objectValue);
}

@Test
public void testAddsTwoFieldsInNestedObject() {
ObjectValue objectValue = new ObjectValue();
objectValue.set(field("a.b"), fooValue);
objectValue.set(field("a.c"), fooValue);
assertEquals(wrapObject("a", map("b", fooString, "c", fooString)), objectValue);
}

@Test
public void testAddDeeplyNestedFieldInNestedObject() {
ObjectValue objectValue = new ObjectValue();
objectValue.set(field("a.b.c.d.e.f"), fooValue);
assertEquals(
wrapObject("a", map("b", map("c", map("d", map("e", map("f", fooString)))))), objectValue);
}

@Test
public void testAddsSingleFieldInExistingObject() {
ObjectValue objectValue = wrapObject("a", fooString);
objectValue.set(field("b"), fooValue);
assertEquals(wrapObject("a", fooString, "b", fooString), objectValue);
}

@Test
public void testSetsNestedFieldMultipleTimes() {
ObjectValue objectValue = new ObjectValue();
objectValue.set(field("a.c"), fooValue);
objectValue.set(field("a"), wrapObject("b", fooString).get(FieldPath.EMPTY_PATH));
assertEquals(wrapObject("a", map("b", fooString)), objectValue);
}

@Test
public void testImplicitlyCreatesObjects() {
ObjectValue objectValue = wrapObject("a", "old");
Expand Down Expand Up @@ -159,12 +251,38 @@ public void testDeletesNestedKeys() {
}

@Test
public void testDeletesMultipleFields() {
ObjectValue object = wrapObject("a", "a", "b", "b", "c", "c");
object.delete(field("a"));
object.delete(field("b"));
object.delete(field("c"));
public void testDeletesNestedObject() {
ObjectValue objectValue =
wrapObject("a", map("b", map("c", fooString, "d", fooString), "f", fooString));
objectValue.delete(field("a.b"));
assertEquals(wrapObject("a", map("f", fooString)), objectValue);
}

@Test
public void testAddsAndDeletesField() {
ObjectValue objectValue = new ObjectValue();
objectValue.set(field(fooString), fooValue);
objectValue.delete(field(fooString));
assertEquals(wrapObject(), objectValue);
}

assertEquals(new ObjectValue(), object);
@Test
public void testAddsAndDeletesNestedField() {
ObjectValue objectValue = new ObjectValue();
objectValue.set(field("a.b.c"), fooValue);
objectValue.set(field("a.b.d"), fooValue);
objectValue.set(field("f.g"), fooValue);
objectValue.set(field("h"), fooValue);
objectValue.delete(field("a.b.c"));
objectValue.delete(field("h"));
assertEquals(
wrapObject("a", map("b", map("d", fooString)), "f", map("g", fooString)), objectValue);
}

@Test
public void testMergesExistingObject() {
ObjectValue objectValue = wrapObject("a", map("b", fooString));
objectValue.set(field("a.c"), fooValue);
assertEquals(wrapObject("a", map("b", fooString, "c", fooString)), objectValue);
}
}