use of org.talend.dataquality.domain.pattern.Pattern in project tdq-studio-se by Talend.
the class DbmsLanguageTest method testGetRegexpGetNullWhenRegexStringIsNull.
/**
* Test method for
* {@link org.talend.dq.dbms.DbmsLanguage#getRegexp(org.talend.dataquality.domain.pattern.Pattern, boolean)}.
*/
@Test
public void testGetRegexpGetNullWhenRegexStringIsNull() {
// Pattern
Pattern createPattern = PatternFactory.eINSTANCE.createPattern();
// ~Pattern
// init sql Expression data
RegularExpression createSqlRegularExpression = PatternFactory.eINSTANCE.createRegularExpression();
EList<PatternComponent> components = createPattern.getComponents();
components.add(createSqlRegularExpression);
// ~init sql Expression data
try {
DbmsLanguage dbms = DbmsLanguageFactory.createDbmsLanguage(SupportDBUrlType.MSSQLDEFAULTURL);
Assert.assertTrue(null == dbms.getRegexp(createPattern));
} catch (Exception e) {
fail(e.getMessage());
}
}
use of org.talend.dataquality.domain.pattern.Pattern in project tdq-studio-se by Talend.
the class DbmsLanguageTest method testGetRegexpGetJavaFromContainDefault.
/**
* Test method for
* {@link org.talend.dq.dbms.DbmsLanguage#getRegexp(org.talend.dataquality.domain.pattern.Pattern, boolean)}.
*/
@Test
public void testGetRegexpGetJavaFromContainDefault() {
// Pattern
Pattern createPattern = PatternFactory.eINSTANCE.createPattern();
// ~Pattern
// init sql Expression data
RegularExpression createSqlRegularExpression = PatternFactory.eINSTANCE.createRegularExpression();
TdExpression createSqlTdExpression = RelationalFactory.eINSTANCE.createTdExpression();
createSqlTdExpression.setBody(SqlRegex);
createSqlTdExpression.setLanguage(ExecutionLanguage.SQL.getName());
createSqlRegularExpression.setExpression(createSqlTdExpression);
createSqlRegularExpression.setExpressionType(ExpressionType.REGEXP.getLiteral());
EList<PatternComponent> components = createPattern.getComponents();
components.add(createSqlRegularExpression);
// ~init sql Expression data
// init mssql Expression data
RegularExpression createMssqlRegularExpression = PatternFactory.eINSTANCE.createRegularExpression();
TdExpression createMssqlTdExpression = RelationalFactory.eINSTANCE.createTdExpression();
createMssqlTdExpression.setBody(MssqlRegex);
createMssqlTdExpression.setLanguage(SupportDBUrlType.MSSQLDEFAULTURL.getLanguage());
createMssqlRegularExpression.setExpression(createMssqlTdExpression);
createMssqlRegularExpression.setExpressionType(ExpressionType.REGEXP.getLiteral());
components = createPattern.getComponents();
components.add(createMssqlRegularExpression);
// ~init mssql Expression data
// init java Expression data
RegularExpression createJavaRegularExpression = PatternFactory.eINSTANCE.createRegularExpression();
TdExpression createJavaTdExpression = RelationalFactory.eINSTANCE.createTdExpression();
createJavaTdExpression.setBody(JavaRegex);
createJavaTdExpression.setLanguage(SupportDBUrlType.JAVADEFAULTURL.getLanguage());
createJavaRegularExpression.setExpression(createJavaTdExpression);
createJavaRegularExpression.setExpressionType(ExpressionType.REGEXP.getLiteral());
components = createPattern.getComponents();
components.add(createJavaRegularExpression);
try {
DbmsLanguage dbms = DbmsLanguageFactory.createDbmsLanguage(SupportDBUrlType.JAVADEFAULTURL);
Assert.assertTrue(JavaRegex.equalsIgnoreCase(dbms.getRegexp(createPattern).getBody()));
} catch (Exception e) {
fail(e.getMessage());
}
}
use of org.talend.dataquality.domain.pattern.Pattern in project tdq-studio-se by Talend.
the class UnitTestBuildHelper method createRealPattern.
public static Pattern createRealPattern() {
Pattern pattern = PatternFactory.eINSTANCE.createPattern();
// $NON-NLS-1$
pattern.setName("My Pattern");
RegularExpression regularExpr = PatternFactory.eINSTANCE.createRegularExpression();
TdExpression expression = createRealExpression();
regularExpr.setExpression(expression);
pattern.getComponents().add(regularExpr);
return pattern;
}
use of org.talend.dataquality.domain.pattern.Pattern in project tdq-studio-se by Talend.
the class FileSystemImportWriterTest method testMergePattern.
/**
* Test method for
* {@link org.talend.dataprofiler.core.ui.imex.model.FileSystemImportWriter#mergePattern(org.talend.dataprofiler.core.ui.imex.model.ItemRecord, org.talend.dataquality.domain.pattern.Pattern)}
* .
*
* @throws MalformedURLException
*/
@Test
public void testMergePattern() throws MalformedURLException {
// import object
ItemRecord importItem = mock(ItemRecord.class);
Pattern importPattern = mock(Pattern.class);
when(importItem.getElement()).thenReturn(importPattern);
// old object
TDQPatternItem oldPatternItem = mock(TDQPatternItem.class);
Pattern oldPattern = mock(Pattern.class);
when(oldPatternItem.getPattern()).thenReturn(oldPattern);
// for imported pattern's expression
InternalEObject eo = mock(InternalEObject.class);
EList<PatternComponent> importComponents = new EObjectContainmentEList<PatternComponent>(PatternComponent.class, eo, PatternPackage.PATTERN__COMPONENTS);
RegularExpression re = PatternFactory.eINSTANCE.createRegularExpression();
TdExpression td = RelationalFactory.eINSTANCE.createTdExpression();
// $NON-NLS-1$
td.setBody("sql body");
// $NON-NLS-1$
td.setLanguage("SQL");
// $NON-NLS-1$
td.setModificationDate("20130101");
re.setExpression(td);
importComponents.add(re);
RegularExpression re3 = PatternFactory.eINSTANCE.createRegularExpression();
TdExpression td3 = RelationalFactory.eINSTANCE.createTdExpression();
// $NON-NLS-1$
td3.setBody("imported body");
// $NON-NLS-1$
td3.setLanguage("MYSQL");
// $NON-NLS-1$
td3.setModificationDate("20130101");
re3.setExpression(td3);
importComponents.add(re3);
RegularExpression re4 = PatternFactory.eINSTANCE.createRegularExpression();
TdExpression td4 = RelationalFactory.eINSTANCE.createTdExpression();
// $NON-NLS-1$
td4.setBody("imported 4 body");
// $NON-NLS-1$
td4.setLanguage("Default");
td4.setModificationDate(null);
re4.setExpression(td4);
importComponents.add(re4);
when(importPattern.getComponents()).thenReturn(importComponents);
// for imported pattern's supplierDependencies
Analysis analysis = mock(Analysis.class);
Dependency dependency = mock(Dependency.class);
when(dependency.getKind()).thenReturn(DependenciesHandler.USAGE);
EList<ModelElement> analysisList = new BasicEList<ModelElement>();
analysisList.add(analysis);
when(dependency.getClient()).thenReturn(analysisList);
when(analysis.eIsProxy()).thenReturn(false);
// $NON-NLS-1$
File file = new File("C://Users//msjian//Desktop//myusetest//AA//TDQ_Data Profiling//Analyses//k_0.1.ana");
org.eclipse.emf.common.util.URI uri = URI.createFileURI(file.toURL().getPath().substring(1));
Resource resource = mock(Resource.class);
when(analysis.eResource()).thenReturn(resource);
when(resource.getURI()).thenReturn(uri);
PowerMockito.mockStatic(ResourceManager.class);
IProject pro = mock(IProject.class);
when(ResourceManager.getRootProject()).thenReturn(pro);
// $NON-NLS-1$
when(pro.getLocation()).thenReturn(new Path("D:\\worspace\\workspace_TDQEE_5.3\\A"));
EList<ModelElement> patternlist = mock(EObjectContainmentEList.class);
patternlist.add(importPattern);
when(dependency.getSupplier()).thenReturn(patternlist);
EList<Dependency> supplierDependencies_old = new BasicEList<Dependency>();
when(oldPattern.getSupplierDependency()).thenReturn(supplierDependencies_old);
Assert.assertEquals(0, oldPattern.getSupplierDependency().size());
EList<Dependency> supplierDependencies_import = new BasicEList<Dependency>();
supplierDependencies_import.add(dependency);
when(importPattern.getSupplierDependency()).thenReturn(supplierDependencies_import);
Assert.assertEquals(1, importPattern.getSupplierDependency().size());
PowerMockito.mockStatic(DependenciesHandler.class);
DependenciesHandler instance = mock(DependenciesHandler.class);
when(DependenciesHandler.getInstance()).thenReturn(instance);
TypedReturnCode<Dependency> rc = new TypedReturnCode<Dependency>();
rc.setObject(dependency);
when(instance.setUsageDependencyOn(analysis, oldPattern)).thenReturn(rc);
when(oldPattern.getSupplierDependency()).thenReturn(supplierDependencies_import);
// for system pattern's expression
EList<PatternComponent> components = new EObjectContainmentEList<PatternComponent>(PatternComponent.class, eo, PatternPackage.PATTERN__COMPONENTS);
RegularExpression re2 = PatternFactory.eINSTANCE.createRegularExpression();
TdExpression td2 = RelationalFactory.eINSTANCE.createTdExpression();
// $NON-NLS-1$
td2.setBody("system 2 body");
// $NON-NLS-1$
td2.setLanguage("MYSQL");
// $NON-NLS-1$
td2.setModificationDate("20120101");
re2.setExpression(td2);
components.add(re2);
// for re5: should be replace by re4
RegularExpression re5 = PatternFactory.eINSTANCE.createRegularExpression();
TdExpression td5 = RelationalFactory.eINSTANCE.createTdExpression();
// $NON-NLS-1$
td5.setBody("system 5 body");
// $NON-NLS-1$
td5.setLanguage("Default");
td5.setModificationDate(null);
re5.setExpression(td5);
components.add(re5);
when(oldPattern.getComponents()).thenReturn(components);
ElementWriterFactory ewFactory = mock(ElementWriterFactory.class);
PatternWriter pw = mock(PatternWriter.class);
when(pw.save(oldPatternItem, true)).thenReturn(null);
// $NON-NLS-1$
stub(method(ElementWriterFactory.class, "getInstance")).toReturn(ewFactory);
when(ewFactory.createPatternWriter()).thenReturn(pw);
writer.mergePattern(importItem, oldPatternItem);
for (PatternComponent component : components) {
TdExpression ex = ((RegularExpression) component).getExpression();
if (ex.getLanguage().equals("SQL")) {
// $NON-NLS-1$
// $NON-NLS-1$
Assert.assertEquals("sql body", ex.getBody());
} else if (ex.getLanguage().equals("MYSQL")) {
// $NON-NLS-1$
// $NON-NLS-1$
Assert.assertEquals("imported body", ex.getBody());
} else if (ex.getLanguage().equals("Default")) {
// $NON-NLS-1$
// $NON-NLS-1$
Assert.assertEquals("imported 4 body", ex.getBody());
}
}
Assert.assertNotNull(oldPattern.getSupplierDependency());
Assert.assertEquals(1, oldPattern.getSupplierDependency().size());
}
use of org.talend.dataquality.domain.pattern.Pattern in project tdq-studio-se by Talend.
the class IndicatorHelperTest method testGetPatternName.
/**
* Test method for get pattern name based on indicator.
*/
@Test
public void testGetPatternName() {
Indicator indicator = IndicatorsFactory.eINSTANCE.createRegexpMatchingIndicator();
IndicatorParameters parameters = IndicatorsFactory.eINSTANCE.createIndicatorParameters();
Domain validData = DomainFactory.eINSTANCE.createDomain();
Pattern pattern = PatternFactory.eINSTANCE.createPattern();
// $NON-NLS-1$
String pn = "Blank Text";
pattern.setName(pn);
validData.getPatterns().add(pattern);
parameters.setDataValidDomain(validData);
indicator.setParameters(parameters);
String patternName = IndicatorHelper.getPatternName(indicator);
assert (patternName.equals(pn));
}
Aggregations