tests/ui/src/com/android/car/calendar/CarCalendarUiTest.java - platform/packages/apps/Car/Calendar - Git at Google

 /*
  * Copyright 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.car.calendar;

 import static androidx.test.espresso.Espresso.onView;
 import static androidx.test.espresso.action.ViewActions.click;
 import static androidx.test.espresso.assertion.ViewAssertions.doesNotExist;
 import static androidx.test.espresso.assertion.ViewAssertions.matches;
 import static androidx.test.espresso.matcher.ViewMatchers.isDisplayed;
 import static androidx.test.espresso.matcher.ViewMatchers.withId;
 import static androidx.test.espresso.matcher.ViewMatchers.withText;

 import static org.hamcrest.CoreMatchers.not;

 import android.Manifest;
 import android.app.Activity;
 import android.content.Context;
 import android.database.Cursor;
 import android.database.MatrixCursor;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.CancellationSignal;
 import android.provider.CalendarContract;
 import android.test.mock.MockContentProvider;
 import android.test.mock.MockContentResolver;

 import androidx.lifecycle.Observer;
 import androidx.lifecycle.ViewModelProvider;
 import androidx.test.core.app.ActivityScenario;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import androidx.test.filters.LargeTest;
 import androidx.test.platform.app.InstrumentationRegistry;
 import androidx.test.rule.GrantPermissionRule;
 import androidx.test.runner.lifecycle.ActivityLifecycleCallback;
 import androidx.test.runner.lifecycle.ActivityLifecycleMonitorRegistry;
 import androidx.test.runner.lifecycle.Stage;

 import com.android.car.calendar.common.Event;
 import com.android.car.calendar.common.EventsLiveData;

 import com.google.common.collect.ImmutableList;

 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;

 import java.time.Clock;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;

 @LargeTest
 @RunWith(AndroidJUnit4.class)
 public class CarCalendarUiTest {
     private static final ZoneId BERLIN_ZONE_ID = ZoneId.of("Europe/Berlin");
     private static final ZoneId UTC_ZONE_ID = ZoneId.of("UTC");
     private static final Locale LOCALE = Locale.ENGLISH;
     private static final ZonedDateTime CURRENT_DATE_TIME =
             LocalDateTime.of(2019, 12, 10, 10, 10, 10, 500500).atZone(BERLIN_ZONE_ID);
     private static final ZonedDateTime START_DATE_TIME =
             CURRENT_DATE_TIME.truncatedTo(ChronoUnit.HOURS);
     private static final String EVENT_TITLE = "the title";
     private static final String EVENT_LOCATION = "the location";
     private static final String EVENT_DESCRIPTION = "the description";
     private static final String CALENDAR_NAME = "the calendar name";
     private static final int CALENDAR_COLOR = 0xCAFEBABE;
     private static final int EVENT_ATTENDEE_STATUS =
             CalendarContract.Attendees.ATTENDEE_STATUS_ACCEPTED;

     private final ActivityLifecycleCallback mLifecycleCallback = this::onActivityLifecycleChanged;

     @Rule
     public final GrantPermissionRule permissionRule =
             GrantPermissionRule.grant(Manifest.permission.READ_CALENDAR);

     private List<Object[]> mTestEventRows;

     // These can be set in the test thread and read on the main thread.
     private volatile CountDownLatch mEventChangesLatch;

     @Before
     public void setUp() {
         ActivityLifecycleMonitorRegistry.getInstance().addLifecycleCallback(mLifecycleCallback);
         mTestEventRows = new ArrayList<>();
     }

     private void onActivityLifecycleChanged(Activity activity, Stage stage) {
         if (stage.equals(Stage.PRE_ON_CREATE)) {
             setActivityDependencies((CarCalendarActivity) activity);
         } else if (stage.equals(Stage.CREATED)) {
             observeEventsLiveData((CarCalendarActivity) activity);
         }
     }

     private void setActivityDependencies(CarCalendarActivity activity) {
         Clock fixedTimeClock = Clock.fixed(CURRENT_DATE_TIME.toInstant(), BERLIN_ZONE_ID);
         Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
         MockContentResolver mockContentResolver = new MockContentResolver(context);
         TestCalendarContentProvider testCalendarContentProvider =
                 new TestCalendarContentProvider(context);
         mockContentResolver.addProvider(CalendarContract.AUTHORITY, testCalendarContentProvider);
         activity.mDependencies =
                 new CarCalendarActivity.Dependencies(LOCALE, fixedTimeClock, mockContentResolver);
     }

     private void observeEventsLiveData(CarCalendarActivity activity) {
         CarCalendarViewModel carCalendarViewModel =
                 new ViewModelProvider(activity).get(CarCalendarViewModel.class);
         EventsLiveData eventsLiveData = carCalendarViewModel.getEventsLiveData();
         mEventChangesLatch = new CountDownLatch(1);

         // Notifications occur on the main thread.
         eventsLiveData.observeForever(
                 new Observer<ImmutableList<Event>>() {
                     // Ignore the first change event triggered on registration with default value.
                     boolean mIgnoredFirstChange;

                     @Override
                     public void onChanged(ImmutableList<Event> events) {
                         if (mIgnoredFirstChange) {
                             // Signal that the events were changed and notified on main thread.
                             mEventChangesLatch.countDown();
                         }
                         mIgnoredFirstChange = true;
                     }
                 });
     }

     @After
     public void tearDown() {
         ActivityLifecycleMonitorRegistry.getInstance().removeLifecycleCallback(mLifecycleCallback);
     }

     @Test
     public void calendar_titleShows() {
         try (ActivityScenario<CarCalendarActivity> ignored =
                 ActivityScenario.launch(CarCalendarActivity.class)) {
             onView(withText(R.string.app_name)).check(matches(isDisplayed()));
         }
     }

     @Test
     public void event_displayed() {
         mTestEventRows.add(buildTestRow(START_DATE_TIME, 1, EVENT_TITLE, false));
         try (ActivityScenario<CarCalendarActivity> ignored =
                 ActivityScenario.launch(CarCalendarActivity.class)) {
             waitForEventsChange();

             // Wait for the UI to be updated with changed events.
             InstrumentationRegistry.getInstrumentation().waitForIdleSync();

             onView(withText(EVENT_TITLE)).check(matches(isDisplayed()));
         }
     }

     @Test
     public void singleAllDayEvent_notCollapsed() {
         // All day events are stored in UTC time.
         ZonedDateTime utcDayStartTime =
                 START_DATE_TIME.withZoneSameInstant(UTC_ZONE_ID).truncatedTo(ChronoUnit.DAYS);

         mTestEventRows.add(buildTestRow(utcDayStartTime, 24, EVENT_TITLE, true));

         try (ActivityScenario<CarCalendarActivity> ignored =
                 ActivityScenario.launch(CarCalendarActivity.class)) {
             waitForEventsChange();

             // Wait for the UI to be updated with changed events.
             InstrumentationRegistry.getInstrumentation().waitForIdleSync();

             // A single all-day event should not be collapsible.
             onView(withId(R.id.expand_collapse_icon)).check(doesNotExist());
             onView(withText(EVENT_TITLE)).check(matches(isDisplayed()));
         }
     }

     @Test
     public void multipleAllDayEvents_collapsed() {
         mTestEventRows.add(buildTestRowAllDay(EVENT_TITLE));
         mTestEventRows.add(buildTestRowAllDay("Another all day event"));

         try (ActivityScenario<CarCalendarActivity> ignored =
                 ActivityScenario.launch(CarCalendarActivity.class)) {
             waitForEventsChange();

             // Wait for the UI to be updated with changed events.
             InstrumentationRegistry.getInstrumentation().waitForIdleSync();

             // Multiple all-day events should be collapsed.
             onView(withId(R.id.expand_collapse_icon)).check(matches(isDisplayed()));
             onView(withText(EVENT_TITLE)).check(matches(not(isDisplayed())));
         }
     }

     @Test
     public void multipleAllDayEvents_expands() {
         mTestEventRows.add(buildTestRowAllDay(EVENT_TITLE));
         mTestEventRows.add(buildTestRowAllDay("Another all day event"));

         try (ActivityScenario<CarCalendarActivity> ignored =
                 ActivityScenario.launch(CarCalendarActivity.class)) {
             waitForEventsChange();

             // Wait for the UI to be updated with changed events.
             InstrumentationRegistry.getInstrumentation().waitForIdleSync();

             // Multiple all-day events should be collapsed.
             onView(withId(R.id.expand_collapse_icon)).perform(click());
             InstrumentationRegistry.getInstrumentation().waitForIdleSync();
             onView(withText(EVENT_TITLE)).check(matches(isDisplayed()));
         }
     }

     private void waitForEventsChange() {
         try {
             mEventChangesLatch.await(10, TimeUnit.SECONDS);
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
     }

     private class TestCalendarContentProvider extends MockContentProvider {
         TestCalendarContentProvider(Context context) {
             super(context);
         }

         @Override
         public Cursor query(
                 Uri uri,
                 String[] projection,
                 Bundle queryArgs,
                 CancellationSignal cancellationSignal) {
             if (uri.toString().startsWith(CalendarContract.Instances.CONTENT_URI.toString())) {
                 MatrixCursor cursor =
                         new MatrixCursor(
                                 new String[] {
                                     CalendarContract.Instances.TITLE,
                                     CalendarContract.Instances.ALL_DAY,
                                     CalendarContract.Instances.BEGIN,
                                     CalendarContract.Instances.END,
                                     CalendarContract.Instances.DESCRIPTION,
                                     CalendarContract.Instances.EVENT_LOCATION,
                                     CalendarContract.Instances.SELF_ATTENDEE_STATUS,
                                     CalendarContract.Instances.CALENDAR_COLOR,
                                     CalendarContract.Instances.CALENDAR_DISPLAY_NAME,
                                 });
                 for (Object[] row : mTestEventRows) {
                     cursor.addRow(row);
                 }
                 return cursor;
             } else if (uri.equals(CalendarContract.Calendars.CONTENT_URI)) {
                 MatrixCursor cursor = new MatrixCursor(new String[] {" Test name"});
                 cursor.addRow(new String[] {"Test value"});
                 return cursor;
             }
             throw new IllegalStateException("Unexpected query uri " + uri);
         }
     }

     private Object[] buildTestRowAllDay(String title) {
         // All day events are stored in UTC time.
         ZonedDateTime utcDayStartTime =
                 START_DATE_TIME.withZoneSameInstant(UTC_ZONE_ID).truncatedTo(ChronoUnit.DAYS);
         return buildTestRow(utcDayStartTime, 24, title, true);
     }

     private static Object[] buildTestRow(
             ZonedDateTime startDateTime, int eventDurationHours, String title, boolean allDay) {
         return new Object[] {
             title,
             allDay ? 1 : 0,
             startDateTime.toInstant().toEpochMilli(),
             startDateTime.plusHours(eventDurationHours).toInstant().toEpochMilli(),
             EVENT_DESCRIPTION,
             EVENT_LOCATION,
             EVENT_ATTENDEE_STATUS,
             CALENDAR_COLOR,
             CALENDAR_NAME
         };
     }
 }
	/*
	* Copyright 2020 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.car.calendar;

	import static androidx.test.espresso.Espresso.onView;
	import static androidx.test.espresso.action.ViewActions.click;
	import static androidx.test.espresso.assertion.ViewAssertions.doesNotExist;
	import static androidx.test.espresso.assertion.ViewAssertions.matches;
	import static androidx.test.espresso.matcher.ViewMatchers.isDisplayed;
	import static androidx.test.espresso.matcher.ViewMatchers.withId;
	import static androidx.test.espresso.matcher.ViewMatchers.withText;

	import static org.hamcrest.CoreMatchers.not;

	import android.Manifest;
	import android.app.Activity;
	import android.content.Context;
	import android.database.Cursor;
	import android.database.MatrixCursor;
	import android.net.Uri;
	import android.os.Bundle;
	import android.os.CancellationSignal;
	import android.provider.CalendarContract;
	import android.test.mock.MockContentProvider;
	import android.test.mock.MockContentResolver;

	import androidx.lifecycle.Observer;
	import androidx.lifecycle.ViewModelProvider;
	import androidx.test.core.app.ActivityScenario;
	import androidx.test.ext.junit.runners.AndroidJUnit4;
	import androidx.test.filters.LargeTest;
	import androidx.test.platform.app.InstrumentationRegistry;
	import androidx.test.rule.GrantPermissionRule;
	import androidx.test.runner.lifecycle.ActivityLifecycleCallback;
	import androidx.test.runner.lifecycle.ActivityLifecycleMonitorRegistry;
	import androidx.test.runner.lifecycle.Stage;

	import com.android.car.calendar.common.Event;
	import com.android.car.calendar.common.EventsLiveData;

	import com.google.common.collect.ImmutableList;

	import org.junit.After;
	import org.junit.Before;
	import org.junit.Rule;
	import org.junit.Test;
	import org.junit.runner.RunWith;

	import java.time.Clock;
	import java.time.LocalDateTime;
	import java.time.ZoneId;
	import java.time.ZonedDateTime;
	import java.time.temporal.ChronoUnit;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Locale;
	import java.util.concurrent.CountDownLatch;
	import java.util.concurrent.TimeUnit;

	@LargeTest
	@RunWith(AndroidJUnit4.class)
	public class CarCalendarUiTest {
	private static final ZoneId BERLIN_ZONE_ID = ZoneId.of("Europe/Berlin");
	private static final ZoneId UTC_ZONE_ID = ZoneId.of("UTC");
	private static final Locale LOCALE = Locale.ENGLISH;
	private static final ZonedDateTime CURRENT_DATE_TIME =
	LocalDateTime.of(2019, 12, 10, 10, 10, 10, 500500).atZone(BERLIN_ZONE_ID);
	private static final ZonedDateTime START_DATE_TIME =
	CURRENT_DATE_TIME.truncatedTo(ChronoUnit.HOURS);
	private static final String EVENT_TITLE = "the title";
	private static final String EVENT_LOCATION = "the location";
	private static final String EVENT_DESCRIPTION = "the description";
	private static final String CALENDAR_NAME = "the calendar name";
	private static final int CALENDAR_COLOR = 0xCAFEBABE;
	private static final int EVENT_ATTENDEE_STATUS =
	CalendarContract.Attendees.ATTENDEE_STATUS_ACCEPTED;

	private final ActivityLifecycleCallback mLifecycleCallback = this::onActivityLifecycleChanged;

	@Rule
	public final GrantPermissionRule permissionRule =
	GrantPermissionRule.grant(Manifest.permission.READ_CALENDAR);

	private List<Object[]> mTestEventRows;

	// These can be set in the test thread and read on the main thread.
	private volatile CountDownLatch mEventChangesLatch;

	@Before
	public void setUp() {
	ActivityLifecycleMonitorRegistry.getInstance().addLifecycleCallback(mLifecycleCallback);
	mTestEventRows = new ArrayList<>();
	}

	private void onActivityLifecycleChanged(Activity activity, Stage stage) {
	if (stage.equals(Stage.PRE_ON_CREATE)) {
	setActivityDependencies((CarCalendarActivity) activity);
	} else if (stage.equals(Stage.CREATED)) {
	observeEventsLiveData((CarCalendarActivity) activity);
	}
	}

	private void setActivityDependencies(CarCalendarActivity activity) {
	Clock fixedTimeClock = Clock.fixed(CURRENT_DATE_TIME.toInstant(), BERLIN_ZONE_ID);
	Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
	MockContentResolver mockContentResolver = new MockContentResolver(context);
	TestCalendarContentProvider testCalendarContentProvider =
	new TestCalendarContentProvider(context);
	mockContentResolver.addProvider(CalendarContract.AUTHORITY, testCalendarContentProvider);
	activity.mDependencies =
	new CarCalendarActivity.Dependencies(LOCALE, fixedTimeClock, mockContentResolver);
	}

	private void observeEventsLiveData(CarCalendarActivity activity) {
	CarCalendarViewModel carCalendarViewModel =
	new ViewModelProvider(activity).get(CarCalendarViewModel.class);
	EventsLiveData eventsLiveData = carCalendarViewModel.getEventsLiveData();
	mEventChangesLatch = new CountDownLatch(1);

	// Notifications occur on the main thread.
	eventsLiveData.observeForever(
	new Observer<ImmutableList<Event>>() {
	// Ignore the first change event triggered on registration with default value.
	boolean mIgnoredFirstChange;

	@Override
	public void onChanged(ImmutableList<Event> events) {
	if (mIgnoredFirstChange) {
	// Signal that the events were changed and notified on main thread.
	mEventChangesLatch.countDown();
	}
	mIgnoredFirstChange = true;
	}
	});
	}

	@After
	public void tearDown() {
	ActivityLifecycleMonitorRegistry.getInstance().removeLifecycleCallback(mLifecycleCallback);
	}

	@Test
	public void calendar_titleShows() {
	try (ActivityScenario<CarCalendarActivity> ignored =
	ActivityScenario.launch(CarCalendarActivity.class)) {
	onView(withText(R.string.app_name)).check(matches(isDisplayed()));
	}
	}

	@Test
	public void event_displayed() {
	mTestEventRows.add(buildTestRow(START_DATE_TIME, 1, EVENT_TITLE, false));
	try (ActivityScenario<CarCalendarActivity> ignored =
	ActivityScenario.launch(CarCalendarActivity.class)) {
	waitForEventsChange();

	// Wait for the UI to be updated with changed events.
	InstrumentationRegistry.getInstrumentation().waitForIdleSync();

	onView(withText(EVENT_TITLE)).check(matches(isDisplayed()));
	}
	}

	@Test
	public void singleAllDayEvent_notCollapsed() {
	// All day events are stored in UTC time.
	ZonedDateTime utcDayStartTime =
	START_DATE_TIME.withZoneSameInstant(UTC_ZONE_ID).truncatedTo(ChronoUnit.DAYS);

	mTestEventRows.add(buildTestRow(utcDayStartTime, 24, EVENT_TITLE, true));

	try (ActivityScenario<CarCalendarActivity> ignored =
	ActivityScenario.launch(CarCalendarActivity.class)) {
	waitForEventsChange();

	// Wait for the UI to be updated with changed events.
	InstrumentationRegistry.getInstrumentation().waitForIdleSync();

	// A single all-day event should not be collapsible.
	onView(withId(R.id.expand_collapse_icon)).check(doesNotExist());
	onView(withText(EVENT_TITLE)).check(matches(isDisplayed()));
	}
	}

	@Test
	public void multipleAllDayEvents_collapsed() {
	mTestEventRows.add(buildTestRowAllDay(EVENT_TITLE));
	mTestEventRows.add(buildTestRowAllDay("Another all day event"));

	try (ActivityScenario<CarCalendarActivity> ignored =
	ActivityScenario.launch(CarCalendarActivity.class)) {
	waitForEventsChange();

	// Wait for the UI to be updated with changed events.
	InstrumentationRegistry.getInstrumentation().waitForIdleSync();

	// Multiple all-day events should be collapsed.
	onView(withId(R.id.expand_collapse_icon)).check(matches(isDisplayed()));
	onView(withText(EVENT_TITLE)).check(matches(not(isDisplayed())));
	}
	}

	@Test
	public void multipleAllDayEvents_expands() {
	mTestEventRows.add(buildTestRowAllDay(EVENT_TITLE));
	mTestEventRows.add(buildTestRowAllDay("Another all day event"));

	try (ActivityScenario<CarCalendarActivity> ignored =
	ActivityScenario.launch(CarCalendarActivity.class)) {
	waitForEventsChange();

	// Wait for the UI to be updated with changed events.
	InstrumentationRegistry.getInstrumentation().waitForIdleSync();

	// Multiple all-day events should be collapsed.
	onView(withId(R.id.expand_collapse_icon)).perform(click());
	InstrumentationRegistry.getInstrumentation().waitForIdleSync();
	onView(withText(EVENT_TITLE)).check(matches(isDisplayed()));
	}
	}

	private void waitForEventsChange() {
	try {
	mEventChangesLatch.await(10, TimeUnit.SECONDS);
	} catch (InterruptedException e) {
	throw new RuntimeException(e);
	}
	}

	private class TestCalendarContentProvider extends MockContentProvider {
	TestCalendarContentProvider(Context context) {
	super(context);
	}

	@Override
	public Cursor query(
	Uri uri,
	String[] projection,
	Bundle queryArgs,
	CancellationSignal cancellationSignal) {
	if (uri.toString().startsWith(CalendarContract.Instances.CONTENT_URI.toString())) {
	MatrixCursor cursor =
	new MatrixCursor(
	new String[] {
	CalendarContract.Instances.TITLE,
	CalendarContract.Instances.ALL_DAY,
	CalendarContract.Instances.BEGIN,
	CalendarContract.Instances.END,
	CalendarContract.Instances.DESCRIPTION,
	CalendarContract.Instances.EVENT_LOCATION,
	CalendarContract.Instances.SELF_ATTENDEE_STATUS,
	CalendarContract.Instances.CALENDAR_COLOR,
	CalendarContract.Instances.CALENDAR_DISPLAY_NAME,
	});
	for (Object[] row : mTestEventRows) {
	cursor.addRow(row);
	}
	return cursor;
	} else if (uri.equals(CalendarContract.Calendars.CONTENT_URI)) {
	MatrixCursor cursor = new MatrixCursor(new String[] {" Test name"});
	cursor.addRow(new String[] {"Test value"});
	return cursor;
	}
	throw new IllegalStateException("Unexpected query uri " + uri);
	}
	}

	private Object[] buildTestRowAllDay(String title) {
	// All day events are stored in UTC time.
	ZonedDateTime utcDayStartTime =
	START_DATE_TIME.withZoneSameInstant(UTC_ZONE_ID).truncatedTo(ChronoUnit.DAYS);
	return buildTestRow(utcDayStartTime, 24, title, true);
	}

	private static Object[] buildTestRow(
	ZonedDateTime startDateTime, int eventDurationHours, String title, boolean allDay) {
	return new Object[] {
	title,
	allDay ? 1 : 0,
	startDateTime.toInstant().toEpochMilli(),
	startDateTime.plusHours(eventDurationHours).toInstant().toEpochMilli(),
	EVENT_DESCRIPTION,
	EVENT_LOCATION,
	EVENT_ATTENDEE_STATUS,
	CALENDAR_COLOR,
	CALENDAR_NAME
	};
	}
	}