tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixing unit test compilation issues

Browse Source
This commit is contained in:
Petr Pokorny
2021-01-25 20:03:31 +01:00
parent 78852c6164
commit 0e88c4b198
4 changed files with 1 additions and 420 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/MapboxInjector.java
View File

@@ -13,10 +13,6 @@ public class MapboxInjector {
private static final String FIELD_INSTANCE = "INSTANCE";
private static final String FIELD_ACCOUNTS = "accounts";
public static void inject(@NonNull Context context, @NonNull String accessToken) {
inject(context, accessToken, null);
}
public static void inject(@NonNull Context context, @NonNull String accessToken) {
Mapbox mapbox = new Mapbox(context, accessToken);
try {

2
platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/module/http/HttpRequestUrlTest.kt
View File

@@ -15,7 +15,7 @@ class HttpRequestUrlTest {
@Before
fun setUp() {
MapboxInjector.inject(mockk(relaxed = true), "pk.foobar", "foobar")
MapboxInjector.inject(mockk(relaxed = true), "pk.foobar")
}
@Test

147
platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/module/telemetry/MapEventFactoryTest.java
View File

@@ -1,147 +0,0 @@
import android.os.Build;
import android.os.Bundle;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.mapbox.mapboxsdk.BuildConfig;
import com.mapbox.mapboxsdk.offline.OfflineRegion;
import org.junit.Before;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class MapEventFactoryTest {
private static final float FONT_SCALE = 1.f;
private static final int BATTERY_LEVEL = 50;
private static final String CARRIER = "carrier";
private static final String NETWORK_TYPE = "network";
private static final String CREATED = "2019-04-09";
private static final boolean PLUGIN = true;
private static final float RESOLUTION = 1024.f;
private static final boolean WIFI = true;
private static final String SHAPE = "shape";
private static final Double MIN_ZOOM = 1.0;
private static final Double MAX_ZOOM = 10.0;
private static final String STYLE_URL = "style url";
private static final long SIZE_OF_RESOURCES_COMPLETED = 100;
private static final long NUMBER_OF_TILE_COMPLETED = 1000;
private static final int STATE = OfflineRegion.STATE_ACTIVE;
private static final String SESSION_ID = "001";
private PhoneState phoneState;
private Gson gson = new Gson();
@Before
public void setUp() {
phoneState = new PhoneState();
phoneState.setAccessibilityFontScale(FONT_SCALE);
phoneState.setBatteryLevel(BATTERY_LEVEL);
phoneState.setCarrier(CARRIER);
phoneState.setCellularNetworkType(NETWORK_TYPE);
phoneState.setCreated(CREATED);
phoneState.setOrientation(PhoneState.Orientation.ORIENTATION_LANDSCAPE);
phoneState.setPluggedIn(PLUGIN);
phoneState.setResolution(RESOLUTION);
phoneState.setWifi(WIFI);
}
@Test
public void testMapLoadEvent() {
MapLoadEvent mapLoadEvent = MapEventFactory.buildMapLoadEvent(phoneState);
assertEquals("Android - " + Build.VERSION.RELEASE, mapLoadEvent.getOperatingSystem());
assertEquals(Build.MODEL, mapLoadEvent.getModel());
assertNotNull(mapLoadEvent.getUserId());
assertEquals(BATTERY_LEVEL, mapLoadEvent.getBatteryLevel());
assertEquals(CARRIER, mapLoadEvent.getCarrier());
assertEquals(NETWORK_TYPE, mapLoadEvent.getCellularNetworkType());
assertEquals(CREATED, mapLoadEvent.getCreated());
assertEquals("Landscape", mapLoadEvent.getOrientation());
assertEquals(BuildConfig.MAPBOX_SDK_IDENTIFIER, mapLoadEvent.getSdkIdentifier());
assertEquals(BuildConfig.MAPBOX_SDK_VERSION, mapLoadEvent.getSdkVersion());
assertEquals(PLUGIN, mapLoadEvent.isPluggedIn());
assertEquals(WIFI, mapLoadEvent.isWifi());
assertEquals(FONT_SCALE, mapLoadEvent.getAccessibilityFontScale(), 0);
String json = gson.toJson(mapLoadEvent);
MapLoadEvent event = gson.fromJson(json, MapLoadEvent.class);
assertEquals(mapLoadEvent, event);
}
@Test
public void testOfflineDownloadEndEvent() {
OfflineDownloadEndEvent offlineDownloadEndEvent = MapEventFactory.buildOfflineDownloadCompleteEvent(phoneState,
SHAPE, MIN_ZOOM, MAX_ZOOM, STYLE_URL, SIZE_OF_RESOURCES_COMPLETED, NUMBER_OF_TILE_COMPLETED, STATE);
assertEquals(SHAPE, offlineDownloadEndEvent.getShapeForOfflineRegion());
assertEquals(MIN_ZOOM, offlineDownloadEndEvent.getMinZoom());
assertEquals(MAX_ZOOM, offlineDownloadEndEvent.getMaxZoom());
assertEquals(STYLE_URL, offlineDownloadEndEvent.getStyleURL());
assertEquals(SIZE_OF_RESOURCES_COMPLETED, offlineDownloadEndEvent.getSizeOfResourcesCompleted());
assertEquals(NUMBER_OF_TILE_COMPLETED, offlineDownloadEndEvent.getNumberOfTilesCompleted());
assertEquals(String.valueOf(STATE), offlineDownloadEndEvent.getState());
assertEquals(CREATED, offlineDownloadEndEvent.getCreated());
String json = gson.toJson(offlineDownloadEndEvent);
OfflineDownloadEndEvent event = gson.fromJson(json, OfflineDownloadEndEvent.class);
assertEquals(offlineDownloadEndEvent, event);
}
@Test
public void testOfflineDownloadStartEvent() {
OfflineDownloadStartEvent offlineDownloadStartEvent = MapEventFactory.buildOfflineDownloadStartEvent(phoneState,
SHAPE, MIN_ZOOM, MAX_ZOOM, STYLE_URL);
assertEquals(SHAPE, offlineDownloadStartEvent.getShapeForOfflineRegion());
assertEquals(MIN_ZOOM, offlineDownloadStartEvent.getMinZoom());
assertEquals(MAX_ZOOM, offlineDownloadStartEvent.getMaxZoom());
assertEquals(STYLE_URL, offlineDownloadStartEvent.getStyleURL());
assertEquals(CREATED, offlineDownloadStartEvent.getCreated());
String json = gson.toJson(offlineDownloadStartEvent);
OfflineDownloadStartEvent event = gson.fromJson(json, OfflineDownloadStartEvent.class);
assertEquals(offlineDownloadStartEvent, event);
}
@Test
public void testPerformanceEvent() {
String nameAttribute = "nameAttribute";
String valueAttribute = "100";
String nameCounters = "nameCounters";
Double valuesCounters = 1000.0;
JsonObject metaData = new JsonObject();
metaData.addProperty("os", "android");
metaData.addProperty("manufacturer", Build.MANUFACTURER);
metaData.addProperty("brand", Build.BRAND);
metaData.addProperty("device", Build.MODEL);
metaData.addProperty("version", Build.VERSION.RELEASE);
metaData.addProperty("abi", Build.CPU_ABI);
metaData.addProperty("country", Locale.getDefault().getISO3Country());
metaData.addProperty("ram", "ram");
metaData.addProperty("screenSize", "1000");
Bundle data = mock(Bundle.class);
ArrayList<PerformanceEvent.PerformanceAttribute<String>> attribtueList = new ArrayList<>();
PerformanceAttribute<String> attribute = new PerformanceAttribute<>(nameAttribute, valueAttribute);
attribtueList.add(attribute);
ArrayList<PerformanceEvent.PerformanceAttribute<Double>> countersList = new ArrayList<>();
PerformanceAttribute<Double> counter = new PerformanceAttribute<>(nameCounters, valuesCounters);
countersList.add(counter);
when(data.getString("attributes")).thenReturn(gson.toJson(attribtueList));
when(data.getString("counters")).thenReturn(gson.toJson(countersList));
when(data.getString("metadata")).thenReturn(metaData.toString());
PerformanceEvent performanceEvent = MapEventFactory.buildPerformanceEvent(phoneState,
SESSION_ID, data);
assertEquals(CREATED, performanceEvent.getCreated());
assertEquals(metaData.toString(), performanceEvent.getMetadata().toString());
assertEquals(SESSION_ID, performanceEvent.getSessionId());
List<PerformanceEvent.PerformanceAttribute<String>> attributeList = performanceEvent.getAttributes();
assertEquals(1, attribtueList.size());
assertEquals(attribute, attribtueList.get(0));
List<PerformanceEvent.PerformanceAttribute<Double>> counterList = performanceEvent.getCounters();
assertEquals(1, counterList.size());
assertEquals(counter, counterList.get(0));
}
}

268
platform/android/MapboxGLAndroidSDK/src/test/java/com/mapbox/mapboxsdk/module/telemetry/SchemaTest.java
View File

@@ -1,268 +0,0 @@
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;
import com.google.gson.annotations.SerializedName;
import org.apache.commons.io.IOUtils;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.GZIPInputStream;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
@Ignore("mapbox-gl-native#14691")
public class SchemaTest {
private static final String MAP_LOAD = "map.load";
private static final String MAP_PERFORMANCE = "mobile.performance_trace";
private static final String OFFLINE_DOWNLOAD_END = "map.offlineDownload.end";
private static final String OFFLINE_DOWNLOAD_START = "map.offlineDownload.start";
private static ArrayList<JsonObject> schemaArray;
@BeforeClass
public static void downloadSchema() throws Exception {
unpackSchemas();
}
private static ByteArrayInputStream getFileBytes() throws IOException {
InputStream inputStream = SchemaTest.class.getClassLoader().getResourceAsStream("mobile-event-schemas.jsonl.gz");
byte[] byteOut = IOUtils.toByteArray(inputStream);
return new ByteArrayInputStream(byteOut);
}
private static void unpackSchemas() throws IOException {
ByteArrayInputStream bais = getFileBytes();
GZIPInputStream gzis = new GZIPInputStream(bais);
InputStreamReader reader = new InputStreamReader(gzis);
BufferedReader in = new BufferedReader(reader);
schemaArray = new ArrayList<>();
Gson gson = new Gson();
String readed;
while ((readed = in.readLine()) != null) {
JsonObject schema = gson.fromJson(readed, JsonObject.class);
schemaArray.add(schema);
}
}
@Test
public void checkOfflineDownloadEndEventSize() {
JsonObject schema = grabSchema(OFFLINE_DOWNLOAD_END);
List<Field> fields = grabClassFields(OfflineDownloadEndEvent.class);
assertEquals(schema.size(), fields.size());
}
@Test
public void checkOfflineDownloadEndEventFields() {
JsonObject schema = grabSchema(OFFLINE_DOWNLOAD_END);
List<Field> fields = grabClassFields(OfflineDownloadEndEvent.class);
schemaContainsFields(schema, fields);
}
@Test
public void checkOfflineDownloadStartEventSize() {
JsonObject schema = grabSchema(OFFLINE_DOWNLOAD_START);
List<Field> fields = grabClassFields(OfflineDownloadStartEvent.class);
assertEquals(schema.size(), fields.size());
}
@Test
public void checkOfflineDownloadStartEventFields() {
JsonObject schema = grabSchema(OFFLINE_DOWNLOAD_START);
List<Field> fields = grabClassFields(OfflineDownloadStartEvent.class);
schemaContainsFields(schema, fields);
}
@Test
public void checkMapLoadEventSize() {
JsonObject schema = grabSchema(MAP_LOAD);
List<Field> fields = grabClassFields(MapLoadEvent.class);
assertEquals(schema.size(), fields.size());
}
@Test
public void checkMapLoadEventFields() {
JsonObject schema = grabSchema(MAP_LOAD);
List<Field> fields = grabClassFields(MapLoadEvent.class);
schemaContainsFields(schema, fields);
}
@Test
public void checkPerformanceEventSize() {
JsonObject schema = grabSchema(MAP_PERFORMANCE);
List<Field> fields = grabClassFields(PerformanceEvent.class);
assertEquals(schema.size(), fields.size());
}
@Test
public void checkPerformanceEventFields() {
JsonObject schema = grabSchema(MAP_PERFORMANCE);
List<Field> fields = grabClassFields(PerformanceEvent.class);
schemaContainsFields(schema, fields);
}
private void schemaContainsFields(JsonObject schema, List<Field> fields) {
int distanceRemainingCount = 0;
int durationRemainingCount = 0;
for (int i = 0; i < fields.size(); i++) {
String thisField = String.valueOf(fields.get(i));
String[] fieldArray = thisField.split(" ");
String[] typeArray = fieldArray[fieldArray.length - 2].split("\\.");
String type = typeArray[typeArray.length - 1];
String[] nameArray = fieldArray[fieldArray.length - 1].split("\\.");
String field = nameArray[nameArray.length - 1];
SerializedName serializedName = fields.get(i).getAnnotation(SerializedName.class);
if (serializedName != null) {
field = serializedName.value();
}
if (field.equalsIgnoreCase("durationRemaining")) {
durationRemainingCount++;
if (durationRemainingCount > 1) {
field = "step" + field;
}
}
if (field.equalsIgnoreCase("distanceRemaining")) {
distanceRemainingCount++;
if (distanceRemainingCount > 1) {
field = "step" + field;
}
}
JsonObject thisSchema = findSchema(schema, field);
assertNotNull(thisSchema);
if (thisSchema.has("type")) {
typesMatch(thisSchema, type);
}
}
}
private JsonObject findSchema(JsonObject schema, String field) {
JsonObject thisSchema = schema.getAsJsonObject(field);
return thisSchema;
}
private void typesMatch(JsonObject schema, String type) {
if (type.equalsIgnoreCase("int") || type.equalsIgnoreCase("integer")
|| type.equalsIgnoreCase("double") || type.equalsIgnoreCase("float")
|| type.equalsIgnoreCase("long")) {
type = "number";
}
if (type.contains("[]") || type.equalsIgnoreCase("list")) {
type = "array";
}
if (type.equalsIgnoreCase("jsonobject")) {
type = "object";
}
Class<? extends JsonElement> typeClass = schema.get("type").getClass();
JsonElement jsonElement = new JsonParser().parse(type.toLowerCase());
if (typeClass == JsonPrimitive.class) {
JsonElement typePrimitive = schema.get("type");
assertTrue(typePrimitive.equals(jsonElement));
} else {
JsonArray arrayOfTypes = schema.getAsJsonArray("type");
assertTrue(arrayOfTypes.contains(jsonElement));
}
}
private JsonObject grabSchema(String eventName) {
for (JsonObject thisSchema : schemaArray) {
String name = thisSchema.get("name").getAsString();
if (name.equalsIgnoreCase(eventName)) {
Gson gson = new Gson();
String schemaString = gson.toJson(thisSchema.get("properties"));
JsonObject schema = gson.fromJson(thisSchema.get("properties"), JsonObject.class);
if (schema.has("step")) {
JsonObject stepJson = schema.get("step").getAsJsonObject();
JsonObject stepProperties = stepJson.get("properties").getAsJsonObject();
String stepPropertiesJson = gson.toJson(stepProperties);
schemaString = generateStepSchemaString(stepPropertiesJson, schemaString);
schema = gson.fromJson(schemaString, JsonObject.class);
schema.remove("step");
}
schema.remove("userAgent");
schema.remove("received");
schema.remove("token");
schema.remove("authorization");
schema.remove("owner");
schema.remove("locationAuthorization");
schema.remove("locationEnabled");
schema.remove("skuId");
//temporary need to work out a solution to include this data
schema.remove("platform");
return schema;
}
}
return null;
}
private List<Field> grabClassFields(Class aClass) {
List<Field> fields = new ArrayList<>();
Field[] allFields = aClass.getDeclaredFields();
for (Field field : allFields) {
if (Modifier.isPrivate(field.getModifiers()) && !Modifier.isStatic(field.getModifiers())) {
fields.add(field);
}
}
Field[] superFields = aClass.getSuperclass().getDeclaredFields();
for (Field field : superFields) {
if (Modifier.isPrivate(field.getModifiers()) && !Modifier.isStatic(field.getModifiers())) {
fields.add(field);
}
}
return fields;
}
private String generateStepSchemaString(String stepJson, String schemaString) {
stepJson = stepJson.replace("\"distanceRemaining\"", "\"stepdistanceRemaining\"");
stepJson = stepJson.replace("durationRemaining", "stepdurationRemaining");
stepJson = stepJson.replaceFirst("\\{", ",");
schemaString = schemaString.replaceAll("}$", "");
schemaString = schemaString + stepJson;
return schemaString;
}
}