8756162640

Committed 19 Apr 2024 03:41PM UTC coverage: 36.187% (-0.7%) from 36.931%

Build # 8756162640

Build Type

push

github

Committed by

Gabriel-Darbord

Commit Message

Exporter: Rename classes + Configurable AssertJ strategy

Run Details

29 of 118 new or added lines in 9 files covered. (24.58%)

503 of 1390 relevant lines covered (36.19%)

0.36 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Famix-UnitTest-Exporter/FamixUTAssertJJavaAssertionStrategy.class.st

Class {
        #name : #FamixUTAssertJJavaAssertionStrategy,
        #superclass : #FamixUTAbstractJavaAssertionStrategy,
        #instVars : [
                'ignoringFieldsOfTypes',
                'usingRecursiveComparison',
                'ignoringCollectionOrder'
        ],
        #category : #'Famix-UnitTest-Exporter-Strategies'
}

{ #category : #ast }
FamixUTAssertJJavaAssertionStrategy >> dependencyImportsOn: aFamixUTExporter [

        | model |
        model := aFamixUTExporter model.
        ^ { (model newImportDeclaration
                   qualifiedName: (model newQualifiedName name:
                                            'org.assertj.core.api.Assertions.assertThat');
                   isStatic: true) }
]

{ #category : #exporting }
FamixUTAssertJJavaAssertionStrategy >> export: aFamixUTAssertion on: exporter [
        "Make an assertion using AssertJ: assertThat(actual).isEqualTo(expected)"

        | model expected assertion containsObject |
        model := exporter model.
        expected := aFamixUTAssertion expected.
        assertion := model newMethodInvocation
                             addArgument:
                                     (model newVariableExpression name: 'actual');
                             name: 'assertThat'.
        (self usingRecursiveComparison and: [
                 containsObject := expected containsObject ]) ifTrue: [
                assertion := model newMethodInvocation
                                     receiver: assertion;
                                     name: 'usingRecursiveComparison' ].
        (self ignoringCollectionOrder and: [ expected containsCollection ])
                ifTrue: [
                        assertion := model newMethodInvocation
                                             receiver: assertion;
                                             name: 'ignoringCollectionOrder' ].
        (self ignoringFieldsOfTypes isNotEmpty and: [
                 containsObject ifNil: [ expected containsObject ] ]) ifTrue: [
                assertion := model newMethodInvocation
                                     receiver: assertion;
                                     name: 'ignoringFieldsOfTypes';
                                     arguments:
                                             (ignoringFieldsOfTypes collect: [ :typeName |
                                                              model newClassProperty
                                                                      type: (model newIdentifier name: typeName);
                                                                      fieldName: 'class' ]) ].
        assertion := model newMethodInvocation
                             receiver: assertion;
                             addArgument:
                                     (exporter valueExporter makeVariableExpression:
                                                      expected);
                             name: 'isEqualTo'.
        ^ model newExpressionStatement expression: assertion
]

{ #category : #accessing }
FamixUTAssertJJavaAssertionStrategy >> ignoringCollectionOrder [

        ^ ignoringCollectionOrder ifNil: [ ignoringCollectionOrder := false ]
]

{ #category : #accessing }
FamixUTAssertJJavaAssertionStrategy >> ignoringCollectionOrder: aBoolean [

        ignoringCollectionOrder := aBoolean
]

{ #category : #accessing }
FamixUTAssertJJavaAssertionStrategy >> ignoringFieldsOfTypes [

        ^ ignoringFieldsOfTypes ifNil: [ ignoringFieldsOfTypes := {  } ]
]

{ #category : #accessing }
FamixUTAssertJJavaAssertionStrategy >> ignoringFieldsOfTypes: aCollection [

        ignoringFieldsOfTypes := aCollection
]

{ #category : #accessing }
FamixUTAssertJJavaAssertionStrategy >> usingRecursiveComparison [

        ^ usingRecursiveComparison ifNil: [
                  usingRecursiveComparison := false ]
]

{ #category : #accessing }
FamixUTAssertJJavaAssertionStrategy >> usingRecursiveComparison: aBoolean [

        usingRecursiveComparison := aBoolean
]

1	Class {
2	#name : #FamixUTAssertJJavaAssertionStrategy,
3	#superclass : #FamixUTAbstractJavaAssertionStrategy,
4	#instVars : [
5	'ignoringFieldsOfTypes',
6	'usingRecursiveComparison',
7	'ignoringCollectionOrder'
8	],
9	#category : #'Famix-UnitTest-Exporter-Strategies'
10	}
11
12	{ #category : #ast }
NEW 13	FamixUTAssertJJavaAssertionStrategy >> dependencyImportsOn: aFamixUTExporter [	×
NEW 14		×
NEW 15	\| model \|	×
NEW 16	model := aFamixUTExporter model.	×
NEW 17	^ { (model newImportDeclaration	×
NEW 18	qualifiedName: (model newQualifiedName name:	×
NEW 19	'org.assertj.core.api.Assertions.assertThat');	×
NEW 20	isStatic: true) }	×
NEW 21	]	×
22
23	{ #category : #exporting }
NEW 24	FamixUTAssertJJavaAssertionStrategy >> export: aFamixUTAssertion on: exporter [	×
NEW 25	"Make an assertion using AssertJ: assertThat(actual).isEqualTo(expected)"	×
NEW 26		×
NEW 27	\| model expected assertion containsObject \|	×
NEW 28	model := exporter model.	×
NEW 29	expected := aFamixUTAssertion expected.	×
NEW 30	assertion := model newMethodInvocation	×
NEW 31	addArgument:	×
NEW 32	(model newVariableExpression name: 'actual');	×
NEW 33	name: 'assertThat'.	×
NEW 34	(self usingRecursiveComparison and: [	×
NEW 35	containsObject := expected containsObject ]) ifTrue: [	×
NEW 36	assertion := model newMethodInvocation	×
NEW 37	receiver: assertion;	×
NEW 38	name: 'usingRecursiveComparison' ].	×
NEW 39	(self ignoringCollectionOrder and: [ expected containsCollection ])	×
NEW 40	ifTrue: [	×
NEW 41	assertion := model newMethodInvocation	×
NEW 42	receiver: assertion;	×
NEW 43	name: 'ignoringCollectionOrder' ].	×
NEW 44	(self ignoringFieldsOfTypes isNotEmpty and: [	×
NEW 45	containsObject ifNil: [ expected containsObject ] ]) ifTrue: [	×
NEW 46	assertion := model newMethodInvocation	×
NEW 47	receiver: assertion;	×
NEW 48	name: 'ignoringFieldsOfTypes';	×
NEW 49	arguments:	×
NEW 50	(ignoringFieldsOfTypes collect: [ :typeName \|	×
NEW 51	model newClassProperty	×
NEW 52	type: (model newIdentifier name: typeName);	×
NEW 53	fieldName: 'class' ]) ].	×
NEW 54	assertion := model newMethodInvocation	×
NEW 55	receiver: assertion;	×
NEW 56	addArgument:	×
NEW 57	(exporter valueExporter makeVariableExpression:	×
NEW 58	expected);	×
NEW 59	name: 'isEqualTo'.	×
NEW 60	^ model newExpressionStatement expression: assertion	×
NEW 61	]	×
62
63	{ #category : #accessing }
NEW 64	FamixUTAssertJJavaAssertionStrategy >> ignoringCollectionOrder [	×
NEW 65		×
NEW 66	^ ignoringCollectionOrder ifNil: [ ignoringCollectionOrder := false ]	×
NEW 67	]	×
68
69	{ #category : #accessing }
NEW 70	FamixUTAssertJJavaAssertionStrategy >> ignoringCollectionOrder: aBoolean [	×
NEW 71		×
NEW 72	ignoringCollectionOrder := aBoolean	×
NEW 73	]	×
74
75	{ #category : #accessing }
NEW 76	FamixUTAssertJJavaAssertionStrategy >> ignoringFieldsOfTypes [	×
NEW 77		×
NEW 78	^ ignoringFieldsOfTypes ifNil: [ ignoringFieldsOfTypes := { } ]	×
NEW 79	]	×
80
81	{ #category : #accessing }
NEW 82	FamixUTAssertJJavaAssertionStrategy >> ignoringFieldsOfTypes: aCollection [	×
NEW 83		×
NEW 84	ignoringFieldsOfTypes := aCollection	×
NEW 85	]	×
86
87	{ #category : #accessing }
NEW 88	FamixUTAssertJJavaAssertionStrategy >> usingRecursiveComparison [	×
NEW 89		×
NEW 90	^ usingRecursiveComparison ifNil: [	×
NEW 91	usingRecursiveComparison := false ]	×
NEW 92	]	×
93
94	{ #category : #accessing }
NEW 95	FamixUTAssertJJavaAssertionStrategy >> usingRecursiveComparison: aBoolean [	×
NEW 96		×
NEW 97	usingRecursiveComparison := aBoolean	×
NEW 98	]	×

moosetechnology / Famix-UnitTest / 8756162640

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous