SelectorDropDownDisplayerTest.java

/*
 * Copyright 2017 Red Hat, Inc. and/or its affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * 
 *      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 org.dashbuilder.renderer.client.selector;

import java.util.Arrays;
import java.util.List;

import org.dashbuilder.dataset.DataSet;
import org.dashbuilder.dataset.filter.FilterFactory;
import org.dashbuilder.dataset.group.AggregateFunctionType;
import org.dashbuilder.dataset.group.DataSetGroup;
import org.dashbuilder.dataset.group.Interval;
import org.dashbuilder.displayer.DisplayerSettings;
import org.dashbuilder.displayer.DisplayerSettingsFactory;
import org.dashbuilder.displayer.client.AbstractDisplayerTest;
import org.dashbuilder.displayer.client.DisplayerListener;
import org.jboss.errai.ioc.client.container.SyncBeanDef;
import org.jboss.errai.ioc.client.container.SyncBeanManager;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

import static org.dashbuilder.dataset.ExpenseReportsData.*;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;

@RunWith(MockitoJUnitRunner.class)
public class SelectorDropDownDisplayerTest extends AbstractDisplayerTest {

    @Mock
    SyncBeanManager beanManager;

    @Mock
    SyncBeanDef<SelectorDropDownItem> dropDownItemBean;

    @Mock
    SelectorDropDownItem dropDownItem;

    public SelectorDropDownDisplayer createSelectorDisplayer(DisplayerSettings settings) {
        return initDisplayer(new SelectorDropDownDisplayer(mock(SelectorDropDownDisplayer.View.class), beanManager), settings);
    }

    @Before
    public void setUp() {
        when(beanManager.lookupBean(SelectorDropDownItem.class)).thenReturn(dropDownItemBean);
        when(dropDownItemBean.newInstance()).thenReturn(dropDownItem);
    }

    @Test
    public void testDraw() {
        DisplayerSettings departmentList = DisplayerSettingsFactory.newSelectorSettings()
                .dataset(EXPENSES)
                .group(COLUMN_DEPARTMENT)
                .column(COLUMN_DEPARTMENT)
                .column(COLUMN_ID, AggregateFunctionType.COUNT)
                .filterOn(false, true, false)
                .multiple(false)
                .buildSettings();

        SelectorDropDownDisplayer presenter = createSelectorDisplayer(departmentList);
        SelectorDropDownDisplayer.View view = presenter.getView();
        presenter.draw();

        verify(view).clearItems();
        verify(view).showSelectHint(COLUMN_DEPARTMENT, false);
        verify(view, times(5)).addItem(any());
        verify(view, never()).showResetHint(anyString(), anyBoolean());

        // Verify the entries are sorted by default
        DataSet dataSet = presenter.getDataSetHandler().getLastDataSet();
        assertEquals(dataSet.getValueAt(0, 0), "Engineering");
        assertEquals(dataSet.getValueAt(4, 0), "Support");
    }

    @Test
    public void testNoData() {
        DisplayerSettings departmentList = DisplayerSettingsFactory.newSelectorSettings()
                .dataset(EXPENSES)
                .filter(COLUMN_ID, FilterFactory.isNull())
                .group(COLUMN_DEPARTMENT)
                .column(COLUMN_DEPARTMENT)
                .column(COLUMN_ID, AggregateFunctionType.COUNT)
                .multiple(false)
                .buildSettings();

        SelectorDropDownDisplayer presenter = createSelectorDisplayer(departmentList);
        SelectorDropDownDisplayer.View view = presenter.getView();
        presenter.draw();

        verify(view).clearItems();
        verify(view).showSelectHint(COLUMN_DEPARTMENT, false);
        verify(view, never()).addItem(any());
    }

    @Test
    public void testNullNotShown() {
        DisplayerSettings departmentList = DisplayerSettingsFactory.newSelectorSettings()
                .dataset(EXPENSES)
                .group(COLUMN_DEPARTMENT)
                .column(COLUMN_DEPARTMENT)
                .column(COLUMN_ID, AggregateFunctionType.COUNT)
                .buildSettings();

        // Insert a null entry into the dataset
        DataSet expensesDataSet = clientDataSetManager.getDataSet(EXPENSES);
        int column = expensesDataSet.getColumnIndex(expensesDataSet.getColumnById(COLUMN_DEPARTMENT));
        expensesDataSet.setValueAt(0, column, null);

        // ... and make sure it's not shown
        SelectorDropDownDisplayer presenter = createSelectorDisplayer(departmentList);
        SelectorDropDownDisplayer.View view = presenter.getView();
        presenter.draw();

        verify(view, times(5)).addItem(any());
        verify(view, never()).addItem(null);
    }

    @Test
    public void testSelectDisabled() {
        DisplayerSettings departmentList = DisplayerSettingsFactory.newSelectorSettings()
                .dataset(EXPENSES)
                .group(COLUMN_DEPARTMENT)
                .column(COLUMN_DEPARTMENT)
                .column(COLUMN_ID, AggregateFunctionType.COUNT)
                .filterOff(true)
                .buildSettings();

        SelectorDropDownDisplayer presenter = createSelectorDisplayer(departmentList);
        DisplayerListener listener = mock(DisplayerListener.class);
        SelectorDropDownDisplayer.View view = presenter.getView();
        presenter.draw();

        reset(view);
        presenter.addListener(listener);
        presenter.onItemSelected(dropDownItem);

        // Check filter notifications
        verify(listener, never()).onFilterEnabled(eq(presenter), any(DataSetGroup.class));
        verify(listener, never()).onRedraw(presenter);

        // Ensure data does not change
        verify(view, never()).showResetHint(COLUMN_DEPARTMENT, true);
        verify(view, never()).clearItems();
        verify(view, never()).showSelectHint(COLUMN_DEPARTMENT, true);
        verify(view, never()).addItem(any());
    }

    @Test
    public void testSelectItem() {
        DisplayerSettings departmentList = DisplayerSettingsFactory.newSelectorSettings()
                .dataset(EXPENSES)
                .group(COLUMN_DEPARTMENT)
                .column(COLUMN_DEPARTMENT)
                .column(COLUMN_ID, AggregateFunctionType.COUNT)
                .filterOn(false, true, true)
                .multiple(false)
                .buildSettings();

        SelectorDropDownDisplayer presenter = createSelectorDisplayer(departmentList);
        SelectorDropDownDisplayer.View view = presenter.getView();
        DisplayerListener listener = mock(DisplayerListener.class);
        presenter.draw();

        // Select an item
        reset(view);
        when(dropDownItem.getId()).thenReturn(1);
        presenter.addListener(listener);
        presenter.onItemSelected(dropDownItem);

        // Ensure data does not change
        verify(view, never()).clearItems();
        verify(view, never()).addItem(any());

        // Verify the item selected is correct
        ArgumentCaptor<DataSetGroup> argument = ArgumentCaptor.forClass(DataSetGroup.class);
        verify(view).showResetHint(COLUMN_DEPARTMENT, false);
        verify(view, never()).showSelectHint(COLUMN_DEPARTMENT, false);
        verify(listener).onFilterEnabled(eq(presenter), argument.capture());
        verify(listener, never()).onRedraw(presenter);
        DataSetGroup dataSetGroup = argument.getValue();
        List<Interval> selectedIntervals = dataSetGroup.getSelectedIntervalList();
        assertEquals(selectedIntervals.size(), 1);
        Interval selectedInterval = selectedIntervals.get(0);
        assertEquals(selectedInterval.getName(), "Management");
    }

    @Test
    public void testMultipleSelect() {
        DisplayerSettings departmentList = DisplayerSettingsFactory.newSelectorSettings()
                .dataset(EXPENSES)
                .group(COLUMN_DEPARTMENT)
                .column(COLUMN_DEPARTMENT)
                .column(COLUMN_ID, AggregateFunctionType.COUNT)
                .filterOn(false, true, true)
                .multiple(true)
                .width(100)
                .buildSettings();

        SelectorDropDownDisplayer presenter = createSelectorDisplayer(departmentList);
        SelectorDropDownDisplayer.View view = presenter.getView();
        DisplayerListener listener = mock(DisplayerListener.class);
        presenter.draw();

        // Select an item
        presenter.addListener(listener);
        when(dropDownItem.getId()).thenReturn(1);
        presenter.onItemSelected(dropDownItem);

        // Select another item
        reset(view);
        reset(listener);
        when(dropDownItem.getId()).thenReturn(2);
        presenter.onItemSelected(dropDownItem);

        // Ensure data does not change
        verify(view, never()).clearItems();
        verify(view, never()).addItem(any());

        // Verify the item selected is correct
        ArgumentCaptor<DataSetGroup> argument = ArgumentCaptor.forClass(DataSetGroup.class);
        verify(view).showResetHint(COLUMN_DEPARTMENT, true);
        verify(view, never()).showSelectHint(COLUMN_DEPARTMENT, true);
        verify(view).showCurrentSelection("Management ...", "Management, Sales ");
        verify(listener).onFilterEnabled(eq(presenter), argument.capture());
        verify(listener, never()).onRedraw(presenter);
        DataSetGroup dataSetGroup = argument.getValue();
        List<Interval> selectedIntervals = dataSetGroup.getSelectedIntervalList();
        assertEquals(selectedIntervals.size(), 2);
        Interval selectedInterval1 = selectedIntervals.get(0);
        Interval selectedInterval2 = selectedIntervals.get(1);
        assertEquals(selectedInterval1.getName(), "Management");
        assertEquals(selectedInterval2.getName(), "Sales");

    }

    @Test
    public void testFormatItemList() {
        DisplayerSettings departmentList = DisplayerSettingsFactory.newSelectorSettings()
                .dataset(EXPENSES)
                .group(COLUMN_DEPARTMENT)
                .column(COLUMN_DEPARTMENT)
                .column(COLUMN_ID, AggregateFunctionType.COUNT)
                .filterOn(false, true, true)
                .multiple(true)
                .width(90)
                .buildSettings();

        SelectorDropDownDisplayer presenter = createSelectorDisplayer(departmentList);

        String result = presenter.formatItemList(Arrays.asList("Sales", "Management", "IT"), 200);
        assertEquals(result, "Sales, Management, IT ");

        result = presenter.formatItemList(Arrays.asList("Sales", "Management", "IT"));
        assertEquals(result, "Sales, Management, IT ");

        result = presenter.formatItemList(Arrays.asList("Sales", "Management", "IT"), 150);
        assertEquals(result, "Sales, Managemen...");

        result = presenter.formatItemList(Arrays.asList("Sales", "Management", "IT"), 130);
        assertEquals(result, "Sales, Managem...");

        result = presenter.formatItemList(Arrays.asList("Sales", "Management", "IT"), 60);
        assertEquals(result, "Sales ...");

        result = presenter.formatItemList(Arrays.asList("Sales", "Management", "IT"), 10);
        assertEquals(result, "S...");
    }

    @Test
    public void testDrillDown() {
        DisplayerSettings departmentList = DisplayerSettingsFactory.newSelectorSettings()
                .dataset(EXPENSES)
                .group(COLUMN_DEPARTMENT)
                .column(COLUMN_DEPARTMENT)
                .column(COLUMN_ID, AggregateFunctionType.COUNT)
                .filterOn(true, true, true)
                .multiple(false)
                .buildSettings();

        SelectorDropDownDisplayer presenter = createSelectorDisplayer(departmentList);
        SelectorDropDownDisplayer.View view = presenter.getView();
        DisplayerListener listener = mock(DisplayerListener.class);
        presenter.draw();

        reset(view);
        when(dropDownItem.getId()).thenReturn(1);
        presenter.addListener(listener);
        presenter.onItemSelected(dropDownItem);

        // Check filter notifications
        verify(listener).onFilterEnabled(eq(presenter), any(DataSetGroup.class));
        verify(listener).onRedraw(presenter);

        // Check selector refreshes
        verify(view).clearItems();
        verify(view, atLeastOnce()).showResetHint(COLUMN_DEPARTMENT, false);
        verify(view, never()).showSelectHint(COLUMN_DEPARTMENT, false);
        verify(view, times(1)).addItem(any());
    }

    @Test
    public void testNullEntries() {
        // Insert a null entry into the dataset
        DataSet expensesDataSet = clientDataSetManager.getDataSet(EXPENSES);
        int column = expensesDataSet.getColumnIndex(expensesDataSet.getColumnById(COLUMN_DEPARTMENT));
        expensesDataSet.setValueAt(0, column, null);

        // Create a selector displayer
        DisplayerSettings departmentList = DisplayerSettingsFactory.newSelectorSettings()
                .dataset(EXPENSES)
                .group(COLUMN_DEPARTMENT)
                .column(COLUMN_DEPARTMENT)
                .column(COLUMN_ID, AggregateFunctionType.COUNT)
                .filterOn(false, true, true)
                .buildSettings();

        SelectorDropDownDisplayer presenter = createSelectorDisplayer(departmentList);
        SelectorDropDownDisplayer.View view = presenter.getView();
        DisplayerListener listener = mock(DisplayerListener.class);
        presenter.addListener(listener);
        presenter.draw();

        // Verify that null entries are not shown
        verify(view, times(5)).addItem(any());
        verify(view, never()).addItem(null);

        // Select an item
        reset(listener);
        when(dropDownItem.getId()).thenReturn(1);
        presenter.onItemSelected(dropDownItem);

        // Verify the item selected is correct
        ArgumentCaptor<DataSetGroup> argument = ArgumentCaptor.forClass(DataSetGroup.class);
        verify(listener).onFilterEnabled(eq(presenter), argument.capture());
        DataSetGroup dataSetGroup = argument.getValue();
        Interval selectedInterval = dataSetGroup.getSelectedIntervalList().get(0);
        assertEquals(selectedInterval.getName(), "Engineering");
    }
}