kern/test-src/de/superx/bianalysis/DbMetaAdapterTest.java

package de.superx.bianalysis;

import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import de.superx.BaseDbTest;
import de.superx.bianalysis.metadata.Identifier;
import de.superx.bianalysis.metadata.MetadataImporter;
import de.superx.bianalysis.models.Dimension;
import de.superx.bianalysis.models.DimensionAttribute;
import de.superx.bianalysis.models.FactTable;
import de.superx.bianalysis.models.Filter;
import de.superx.bianalysis.repository.StoredReportRepository;
import de.superx.bianalysis.service.DbMetaAdapter;
import de.superx.bianalysis.service.IllegalMetaDataOperation;

public class DbMetaAdapterTest extends BaseDbTest {

    @Autowired
    DbMetaAdapter dbAdapter;
    
    public static boolean isInitializationDone = false;
    
    public static final String META_DIR = String.join(File.separator,
        "test", 
        "resources", 
        "db", 
        "fixtures", 
        "bianalysis", 
        "meta_adapter", 
        "metadata"
    ); 

    @Before
    public void init() {
        MetadataImporter importer = new MetadataImporter();
        importer.setShouldReadYMLDoc(false);
        importer.deserializeMetadataFromJsonFiles(META_DIR);
        String out = String.join("\n", importer.getAllUpsertStrings(false));
        new JdbcTemplate(this.dataSource).execute(out);
        isInitializationDone = true;
    }
    
    @After 
    public void cleanup() {
        String out = "DELETE FROM metadata.dimension_attribute WHERE namespace IN ('test', 'conf_test', 'rp_test', 'conf_rp_test');"
                   + "DELETE FROM metadata.dimension WHERE namespace IN ('test', 'conf_test', 'rp_test', 'conf_rp_test');"
                   + "DELETE FROM metadata.measure WHERE namespace IN ('test', 'conf_test', 'rp_test', 'conf_rp_test');"
                   + "DELETE FROM metadata.measure_filter WHERE namespace IN ('test', 'conf_test', 'rp_test', 'conf_rp_test');"
                   + "DELETE FROM metadata.facttable WHERE namespace IN ('test', 'conf_test', 'rp_test', 'conf_rp_test');";

        new JdbcTemplate(this.dataSource).execute(out);
    }

    //@Test
    //public void shouldUseHierarchyAttributesForConformedDimensions() {
    //    List<Dimension> dimensions = dbAdapter.getDimensions(new Identifier("test:1"));
    //    Dimension orgunitDim = dimensions.get(0);
    //    assertEquals(1, dimensions.size());
    //    assertEquals(2, orgunitDim.dimensionAttributes.size());
    //    for (DimensionAttribute attribute : orgunitDim.dimensionAttributes) {
    //       assertTrue(attribute.isHierarchy());
    //       if(attribute.getAttrConformedId().equals("conf_test:3121")) {
    //          assertTrue(attribute.isHierarchicalFilter());
    //       }
    //    }
    //}

    @Test
    public void testFilterValuesForNumericColumn() {
        DimensionAttribute age = dbAdapter.getDimensionAttributeMetadataById(new Identifier("app_basic:6"));
        List<String> values = dbAdapter.getDimensionAttributeValues(age, null, null, null, null);
        System.out.println(values);
        assertTrue(values.get(0).equals("n. v."));
        assertTrue(values.get(1).equals("Ungültig"));
        assertTrue(values.get(2).equals("0"));
        assertTrue(values.get(3).equals("1"));
        assertTrue(values.get(7).equals("5"));
        assertTrue(values.get(70).equals("68"));
    }

    @Test
    public void testFilterValuesForUnique() {
        DimensionAttribute semestertyp = dbAdapter.getDimensionAttributeMetadataById(new Identifier("app_basic:100"));
        List<String> typen = dbAdapter.getDimensionAttributeValues(semestertyp, null, null, null, null);
        assertTrue(typen.size() == 3);
        assertTrue(typen.get(0).equals("n. v."));
        assertTrue(typen.get(1).equals("WiSe"));
        assertTrue(typen.get(2).equals("SoSe"));
    }

    @Test
    public void testFilterValuesForSortOrderColumn() {
        DimensionAttribute wochentag = dbAdapter.getDimensionAttributeMetadataById(new Identifier("app_basic:133"));
        List<String> wochentage = dbAdapter.getDimensionAttributeValues(wochentag, null, null, null, null);
        assertTrue(wochentage.size() == 8);
        assertTrue(wochentage.get(0).equals("n. v."));
        assertTrue(wochentage.get(1).equals("Montag"));
        assertTrue(wochentage.get(2).equals("Dienstag"));
        assertTrue(wochentage.get(5).equals("Freitag"));
        assertTrue(wochentage.get(7).equals("Sonntag"));
    }

    @Test
    public void testFilterValuesForTextSorting() {
        DimensionAttribute gender = dbAdapter.getDimensionAttributeMetadataById(new Identifier("app_basic:3"));
        List<String> genders = dbAdapter.getDimensionAttributeValues(gender, null, null, null, null);
        assertTrue(genders.size() == 5);
        assertTrue(genders.get(0).equals("n. v."));
        assertTrue(genders.get(1).equals("männlich"));
        assertTrue(genders.get(2).equals("weiblich"));
        assertTrue(genders.get(3).equals("divers"));
        assertTrue(genders.get(4).equals("undefiniert / k.A."));
    }

    @Test
    public void testTopDimensionAttibuteValuesWithFilter() {
        FactTable factTable = dbAdapter.getFactTable(new Identifier("app_basic:1"));
        List<Dimension> dimensions = dbAdapter.getDimensions(new Identifier("app_basic:1"));
        Dimension age_dimension = dimensions.get(1);
        assertTrue(age_dimension.getId().equals(new Identifier("app_basic:5")));

        DimensionAttribute age = dbAdapter.getDimensionAttributeMetadataById(new Identifier("app_basic:6"));
        DimensionAttribute age_category = dbAdapter.getDimensionAttributeMetadataById(new Identifier("app_basic:12393"));

        List<String> filterValues =  List.of("Unter 18");
        Filter age_category_filter = new Filter(filterValues, new Identifier("app_basic:12393"));
        age_category_filter.setDimension(age_dimension);
        age_category_filter.setDimensionAttribute(age_category);
        List<Filter> filters = new ArrayList<Filter>();
        filters.add(age_category_filter);

        List<String> entries = dbAdapter.getDimensionAttributeValues(age, age_dimension, factTable, filters, Boolean.valueOf(true));
        for( String entry : entries) {
            assertTrue(Integer.parseInt(entry)< 18);
        }
    }

    @Test
    public void testAttributeCannotBeHiddenOrDeletedIfUsedInReport() {
        StoredReport report = new StoredReport();
        report.definition = """
                {
                	"factTableId": "res_nom:1",
                	"filters": [],
                	"hideEmptyColumns": false,
                	"leftDimensionAttributeIds": [ "res_nom:29" ],
                	"measureIds": [ "res_nom:20" ],
                	"secondaryFacttables": [],
                	"topDimensionAttributeIds": []
                }
                """;
        report.name = "my dummy report";
        int reportId = dbAdapter.saveReportDefinition(report);
        
        assertThrows(IllegalMetaDataOperation.class, () -> {
            dbAdapter.hideAttributeById(new Identifier("res_nom:29"), Boolean.valueOf(true));
        });
        assertThrows(IllegalMetaDataOperation.class, () -> {
            dbAdapter.hideDimensionById(new Identifier("res_nom:2"), Boolean.valueOf(true));
        });

        dbAdapter.deleteById(reportId);
    }
}