MolComponentImplTest.class.st

Class {
	#name : #MolComponentImplTest,
	#superclass : #TestCase,
	#category : #'Molecule-Tests-Cases'
}

{ #category : #running }
MolComponentImplTest >> setUp [
	MolComponentManager cleanUp.
	super setUp 
]

{ #category : #running }
MolComponentImplTest >> tearDown [
	super tearDown.
	MolComponentManager cleanUp
]

{ #category : #tests }
MolComponentImplTest >> testAugmentedClassToAComponentProperties [
	| component |

	component := MolAugmentedClassToAComponentWithoutType new.

	self assert: component class isComponentClass.
	self assert: component class haveComponentType equals: false.

	"Component name"
	self assert: component componentName equals: nil.
	component componentName: MolUtils defaultComponentName.
	self assert: component componentName equals: MolUtils defaultComponentName.
	
	"Component connector, just test if accessors exists because componentConnector is managed on component instanciation"
	self assert: component componentConnector equals: nil.
	component componentConnector: nil.
	self assert: component componentConnector equals: nil.
]

{ #category : #tests }
MolComponentImplTest >> testAugmentedClassToAComponentRemoveAndReuseAsNormalWay [
	"Use an existing class to a component, remove the component and reuse the instance as a normal way"

	| myInstance |
	"Start the component"
	myInstance := MolUtils startComponent: MolAugmentedClassToAComponent.
	self assert: myInstance service equals: #service2.
	self assert: myInstance parameter equals: #parameter2.
	
	"Stop the component but after use instance as a normal way"	
	MolUtils stopComponent: MolAugmentedClassToAComponent.
	"Use classic methods wich uses component methods and check if no errors are rising in case of using these methods in the classic implementation"
	self assert: myInstance existingInterfaceA.
	self assert: myInstance existingInterfaceB.
	self assert: myInstance existingInterfaceC.
	myInstance getMolUsedEventsSubscriber subscribe: myInstance.
	myInstance getMolUsedEventsSubscriber unsubscribe: myInstance.
]

{ #category : #tests }
MolComponentImplTest >> testAugmentedClassToAComponentUsesAsAClassicWay [
	"Use existing API outside a Component system but with component capacities use inside (get services, parameters and notify events)"

	| myInstance |
	myInstance := MolAugmentedClassToAComponent new.
	self assert: myInstance existingInterfaceA.
	self assert: myInstance existingInterfaceB.
	self assert: myInstance existingInterfaceC.
]

{ #category : #'tests - connecting - events producers' }
MolComponentImplTest >> testChangeEventsProducersDuringSubscribe [

	| component |
	component := MolCompleteComponentImpl start: #myComponent.
	component getMolUsedEventsSubscriber subscribe: component.
	
	"Change events producers"
	component forEvents: MolUsedEvents addProducer: #componentA.
	
	
	
	
]

{ #category : #'tests - contract' }
MolComponentImplTest >> testComponentType [ 

	self assert: MolBasicComponentImpl componentType equals: MolBasicComponent.
	self assert: MolBasicSubComponentImpl componentType equals: MolBasicComponent.
	
	
]

{ #category : #'tests - contract' }
MolComponentImplTest >> testComponentType2 [

	self assert: MolComponentImpl componentType equals: nil.
	self assert: MolCompleteComponentImpl componentType equals: MolCompleteComponent.
	self assert: MolTestComponentImplA componentType equals: nil.
	
	"inheritance"
	self assert: MolCompleteComponentChildImpl componentType equals: MolCompleteComponentChild.
	
	
]

{ #category : #tests }
MolComponentImplTest >> testDefineComponent [

	self assert: MolComponentImpl defineComponent equals: MolComponentImpl.
]

{ #category : #tests }
MolComponentImplTest >> testEventsNotifiers [

	| component |
	
	component := MolCompleteComponentImpl new.
	
	self assert: component eventsNotifiers isEmpty.
	
	component := MolUtils deployAndInitializeComponent: MolCompleteComponentImpl named: #myComponentA.
	
	"Test initial events producer contents : default component name"
	self assert: component eventsNotifiers size equals: 1.
	self assert: ((component eventsNotifiers at: MolUsedEvents) isKindOf: MolEventNotifier).
	
	MolUtils activateComponent: MolCompleteComponentImpl named: #myComponentA.
	
	self assert: component eventsNotifiers size equals: 1.
	self assert: ((component eventsNotifiers at: MolUsedEvents) isKindOf: MolEventNotifier).
	
	MolUtils passivateComponent: MolCompleteComponentImpl named: #myComponentA.
	
	self assert: component eventsNotifiers size equals: 1.
	self assert: ((component eventsNotifiers at: MolUsedEvents) isKindOf: MolEventNotifier).
	
	MolUtils removeComponent: MolCompleteComponentImpl named: #myComponentA.

	self assert: component eventsNotifiers isEmpty.
]

{ #category : #tests }
MolComponentImplTest >> testEventsSubscribers [

	| component |
	
	component := MolCompleteComponentImpl new.
	
	self assert: component eventsSubscribers isEmpty.
	
	component := MolUtils deployAndInitializeComponent: MolCompleteComponentImpl named: #myComponentA.
	
	"Test initial events producer contents : default component name"
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: MolUtils defaultComponentName.
	
	MolUtils activateComponent: MolCompleteComponentImpl named: #myComponentA.
	
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: MolUtils defaultComponentName.
	
	MolUtils passivateComponent: MolCompleteComponentImpl named: #myComponentA.
	
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: MolUtils defaultComponentName.
	
	MolUtils removeComponent: MolCompleteComponentImpl named: #myComponentA.

	self assert: component eventsSubscribers isEmpty.
]

{ #category : #'tests - connecting - events producers' }
MolComponentImplTest >> testForEventsAddAllProducers [

	| component |
	component := MolCompleteComponentImpl start: #myComponentA.

	component forEvents: MolUsedEvents addAllProducers: #(#producerA #producerB #producerC).
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #(#default #producerA #producerB #producerC).
	
	component forEvents: MolUsedEvents addAllProducers: #(#producerA #producerB #producerC #producerD #producerE #producerF).
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #(#default #producerA #producerB #producerC #producerD #producerE #producerF).
	
	
]

{ #category : #tests }
MolComponentImplTest >> testForEventsAddProducer [

	| component |
	component := MolCompleteComponentImpl start: #myComponentA.
	
	component forEvents: MolUsedEvents addProducer: #producerA.
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #(#default #producerA).
	
	component forEvents: MolUsedEvents addProducer: #producerB.
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #(#default #producerA #producerB).
	
	component forEvents: MolUsedEvents addProducer: MolUtils defaultComponentName.
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #(#default #producerA #producerB).
]

{ #category : #'tests - connecting - events producers' }
MolComponentImplTest >> testForEventsRemoveAllProducers [

	| component |
	component := MolCompleteComponentImpl start: #myComponentA.

	component forEvents: MolUsedEvents addAllProducers: #(#producerA #producerB #producerC).

	component forEvents: MolUsedEvents removeAllProducers: #(#producerA #producerB #producerC #producerD #producerE #producerF).
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: MolUtils defaultComponentName.
	
	component forEvents: MolUsedEvents addAllProducers: #(#producerA #producerB #producerC).
	component forEvents: MolUsedEvents removeAllProducers: #(#producerA).
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #(#default #producerB #producerC).
	
	component forEvents: MolUsedEvents removeAllProducers: #(#default #producerB #producerC).
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: MolUtils defaultComponentName. "Cannot remove the component default name"
	
]

{ #category : #'tests - connecting - events producers' }
MolComponentImplTest >> testForEventsRemoveProducer [

	| component |
	component := MolCompleteComponentImpl start: #myComponentA.
	
	component forEvents: MolUsedEvents useAllProducers: #(#producerA #producerB #producerC).	
		
	component forEvents: MolUsedEvents removeProducer: #producerA.
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #(#producerB #producerC).
	
	component forEvents: MolUsedEvents removeProducer: #producerB.
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #producerC.
	
	component forEvents: MolUsedEvents removeProducer: #producerC.
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: nil.
]

{ #category : #'tests - connecting - events producers' }
MolComponentImplTest >> testForEventsRemoveProducer2 [
	"This test testing if case of remove a producer with the defaultComponentName, it is not done because of this is the basic configuration of a component event"
	| component |
	component := MolCompleteComponentImpl start: #myComponentA.
	
	component forEvents: MolUsedEvents removeProducer: MolUtils defaultComponentName.
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: MolUtils defaultComponentName.
]

{ #category : #'tests - connecting - events producers' }
MolComponentImplTest >> testForEventsUseAllProducers [

	| component |
	component := MolCompleteComponentImpl start: #myComponentA.

	component forEvents: MolUsedEvents useAllProducers: #(#producerA #producerB #producerC).
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #(#producerA #producerB #producerC).
	
	component forEvents: MolUsedEvents useAllProducers: #(#producerD #producerE #producerF).
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #(#producerD #producerE #producerF).
	
	component forEvents: MolUsedEvents useAllProducers: #().
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: nil.
	
	component forEvents: MolUsedEvents useAllProducers: nil.
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: nil.
	
	component forEvents: MolUsedEvents useAllProducers: #(#producerA).
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #producerA.
]

{ #category : #'tests - connecting - events producers' }
MolComponentImplTest >> testForEventsUseProducer [

	| component |
	component := MolCompleteComponentImpl start: #myComponentA.
	
	"Test set a specific producer"
	component forEvents: MolUsedEvents useProducer: #producerA. 
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #producerA.
	
	component forEvents: MolUsedEvents useProducer: #producerB. 
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #producerB.
	
	component forEvents: MolUsedEvents useProducer: nil. 
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: nil.
	
	component forEvents: MolUsedEvents useProducer: MolUtils defaultComponentName. 
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: MolUtils defaultComponentName.
]

{ #category : #'tests - connecting - events producers' }
MolComponentImplTest >> testForEventsUseProducer2 [

	| component |
	component := MolCompleteComponentImpl start: #myComponentA.
	component forEvents: MolUsedEvents useAllProducers: #(#producerA #producerB #producerC). 
	
	component forEvents: MolUsedEvents useProducer: #producerD. 
	self assert: component eventsSubscribers size equals: 1.
	self assert: (component eventsSubscribers at: MolUsedEvents) equals: #producerD.
	
	
]

{ #category : #tests }
MolComponentImplTest >> testGetComponentUsedWithWrongName [
	"Connect two components with different types of component name"
	| providerComponent userComponent |
	
	providerComponent := MolCompleteComponentImpl start: #myComponentName.
	userComponent := MolCompleteComponent2Impl start.
	
	userComponent forServices: MolUsedServices useProvider: #badComponentName.
	userComponent forParameters: MolUsedParameters useProvider: #badComponentName.
	self assert: userComponent getMolUsedServicesProvider isNotFoundServices.
	self assert: userComponent getMolUsedParametersProvider isNotFoundParameters.

	userComponent forServices: MolUsedServices useProvider: 'myComponentName'.
	userComponent forParameters: MolUsedParameters useProvider: 'myComponentName'.
	self assert: userComponent getMolUsedServicesProvider isNotFoundServices.
	self assert: userComponent getMolUsedParametersProvider isNotFoundParameters.

	userComponent forServices: MolUsedServices useProvider: 29.
	userComponent forParameters: MolUsedParameters useProvider: 29.
	self assert: userComponent getMolUsedServicesProvider isNotFoundServices.
	self assert: userComponent getMolUsedParametersProvider isNotFoundParameters.

	userComponent forServices: MolUsedServices useProvider: (OrderedCollection new).
	userComponent forParameters: MolUsedParameters useProvider: (OrderedCollection new).
	self assert: userComponent getMolUsedServicesProvider isNotFoundServices.
	self assert: userComponent getMolUsedParametersProvider isNotFoundParameters.
	
	userComponent forServices: MolUsedServices useProvider: nil.
	userComponent forParameters: MolUsedParameters useProvider: nil.
	self assert: userComponent getMolUsedServicesProvider isNotFoundServices.
	self assert: userComponent getMolUsedParametersProvider isNotFoundParameters.
	
	userComponent forServices: MolUsedServices useProvider: #myComponentName.
	userComponent forParameters: MolUsedParameters useProvider: #myComponentName.
	self assert: userComponent getMolUsedServicesProvider isNotFoundServices not.
	self assert: userComponent getMolUsedParametersProvider isNotFoundParameters not.

]

{ #category : #'tests - contract' }
MolComponentImplTest >> testHaveComponentType [ 

	self assert: MolComponentImpl haveComponentType equals: false.
	self assert: MolBasicComponentImpl haveComponentType equals: true.
	self assert: MolBasicSubComponentImpl haveComponentType equals: true.
]

{ #category : #'tests - contract' }
MolComponentImplTest >> testHaveOwnComponentType [ 

	self assert: MolComponentImpl haveOwnComponentType equals: false.
	self assert: MolBasicComponentImpl haveOwnComponentType equals: true.
	self assert: MolBasicSubComponentImpl haveOwnComponentType equals: false.
]

{ #category : #tests }
MolComponentImplTest >> testIsComponentClass [

	self deny: MolComponentImpl isComponentClass. "This class is not a component class, but users yes"
]

{ #category : #tests }
MolComponentImplTest >> testIsFoundEventsNotifier [

	| component |
	component := MolUtils startComponent: MolCompleteComponentImpl.
	
	self assert: component getMolUsedEventsNotifier isFoundEventsNotifier.
	self assert: component getMolUsedEventsNotifier isNotFoundEventsNotifier not.
]

{ #category : #tests }
MolComponentImplTest >> testIsFoundEventsSubscriber [

	| component |
	component := MolUtils startComponent: MolCompleteComponentImpl.
	
	self assert: component getMolUsedEventsSubscriber isFoundEventsSubscriber.
	self assert: component getMolUsedEventsSubscriber isNotFoundEventsSubscriber not.
]

{ #category : #tests }
MolComponentImplTest >> testIsFoundParameters [

	| component |
	component := MolUtils startComponent: MolCompleteComponentImpl.
	
	self assert: component getMolUsedParametersProvider isFoundParameters.
	self assert: component getMolUsedParametersProvider isNotFoundParameters not.
	
]

{ #category : #tests }
MolComponentImplTest >> testIsFoundServices [

	| component |
	component := MolUtils startComponent: MolCompleteComponentImpl.
	
	self assert: component getMolUsedServicesProvider isFoundServices.
	self assert: component getMolUsedServicesProvider isNotFoundServices not.
]

{ #category : #tests }
MolComponentImplTest >> testIsNotFoundEventsNotifier [

	| component result |
	component := MolCompleteComponentImpl new.
	
	self assert: component getMolUsedEventsNotifier isNotFoundEventsNotifier.
	self assert: component getMolUsedEventsNotifier isFoundEventsNotifier not.
	
	result := component getMolUsedEventsNotifier event.
	self assert: result isNil.
]

{ #category : #tests }
MolComponentImplTest >> testIsNotFoundParameters [

	| component result |
	component := MolCompleteComponentImpl new.
	
	self assert: component getMolUsedParametersProvider isNotFoundParameters.
	self assert: component getMolUsedParametersProvider isFoundParameters not.
	
	result := component getMolUsedParametersProvider parameter.
	self assert: result isNil.
]

{ #category : #tests }
MolComponentImplTest >> testIsNotFoundServices [

	| component result |
	component := MolCompleteComponentImpl new.
	
	self assert: component getMolUsedServicesProvider isNotFoundServices.
	self assert: component getMolUsedServicesProvider isFoundServices not.
	
	result := component getMolUsedServicesProvider service.
	self assert: result isNil.
]

{ #category : #tests }
MolComponentImplTest >> testIsNotFoundSubscriber [

	| component |
	component := MolCompleteComponentImpl new.
	
	self assert: component getMolUsedEventsSubscriber isNotFoundEventsSubscriber.
	self assert: component getMolUsedEventsSubscriber isFoundEventsSubscriber not.
	
	component getMolUsedEventsSubscriber subscribe: self.
	component getMolUsedEventsSubscriber unsubscribe: self.
]

{ #category : #'tests - contract' }
MolComponentImplTest >> testIsOverrideComponentType [

	self assert: MolCompleteComponentImpl isOverrideComponentType equals: false.
	self assert: MolCompleteComponentChildImpl isOverrideComponentType equals: true.
	
	self assert: MolBasicComponentImpl isOverrideComponentType equals: false.
	self assert: MolBasicSubComponentImpl isOverrideComponentType equals: false.
]

{ #category : #tests }
MolComponentImplTest >> testIsSubscribed [

	| component |
	component := MolCompleteComponentImpl start.
	self assert: (component isSubscribed: MolUsedEvents) equals: false. "can be true when subscribe"
	self assert: (component isSubscribed: MolUsedChildEvents) equals: false. "never be true"
	
	component getMolUsedEventsSubscriber subscribe: component.
	self assert: (component isSubscribed: MolUsedEvents) equals: true.
	self assert: (component isSubscribed: MolUsedChildEvents) equals: false. "never be true"
	
	component getMolUsedEventsSubscriber unsubscribe: component.
	self assert: (component isSubscribed: MolUsedEvents) equals: false.
	self assert: (component isSubscribed: MolUsedChildEvents) equals: false. "never be true"
	
	component getMolUsedEventsSubscriber subscribe: component.
	self assert: (component isSubscribed: MolUsedEvents) equals: true.
	self assert: (component isSubscribed: MolUsedChildEvents) equals: false. "never be true"

	MolCompleteComponentImpl stop.
	self assert: (component isSubscribed: MolUsedEvents) equals: false.
	self assert: (component isSubscribed: MolUsedChildEvents) equals: false. "never be true"
]

{ #category : #'tests - contract' }
MolComponentImplTest >> testOverridedComponentTypes [

	self assert: MolCompleteComponentImpl overridedComponentTypes isEmpty.
	self assert: MolCompleteComponentChildImpl overridedComponentTypes size equals: 1.
	self assert: MolCompleteComponentChildImpl overridedComponentTypes first equals: MolCompleteComponent.
]

{ #category : #'tests - contract' }
MolComponentImplTest >> testOwnComponentType [ 

	self assert: MolBasicComponentImpl ownComponentType equals: MolBasicComponent.
	self assert: MolBasicSubComponentImpl ownComponentType equals: nil.
	
	
]

{ #category : #tests }
MolComponentImplTest >> testParametersDoIfNone [

	"First: with found services"
	| component exception |
	component := MolUtils startComponent: MolCompleteComponentImpl.
	component getMolUsedParametersProvider parametersDo: [ :s | 
		self assert: s isFoundParameters.
		self assert: s parameter equals: #parameter.
	] ifNone: [ self fail ].

	"Second: with not found services"
	component := MolCompleteComponentImpl new. 
	component getMolUsedParametersProvider parametersDo: [ :s | self fail ] ifNone: [ 
		exception := true.
	].
	self assert: exception.
]

{ #category : #tests }
MolComponentImplTest >> testParametersProviders [

	| component |
	
	component := MolCompleteComponentImpl new.
	
	self assert: component parametersProviders isEmpty.
	
	component := MolUtils deployAndInitializeComponent: MolCompleteComponentImpl named: #myComponentA.
	
	"Test initial events producer contents : default component name"
	self assert: component parametersProviders size equals: 1.
	self assert: (component parametersProviders at: MolUsedParameters) equals: MolUtils defaultComponentName.
	
	MolUtils activateComponent: MolCompleteComponentImpl named: #myComponentA.
	
	self assert: component parametersProviders size equals: 1.
	self assert: (component parametersProviders at: MolUsedParameters) equals: MolUtils defaultComponentName.
	
	MolUtils passivateComponent: MolCompleteComponentImpl named: #myComponentA.
	
	self assert: component parametersProviders size equals: 1.
	self assert: (component parametersProviders at: MolUsedParameters) equals: MolUtils defaultComponentName.
	
	MolUtils removeComponent: MolCompleteComponentImpl named: #myComponentA.

	self assert: component parametersProviders isEmpty.
]

{ #category : #'tests - connecting - events producers' }
MolComponentImplTest >> testSendEventInAForkDuringCleanUp [

	| component |
	component := MolCompleteComponentForkedImpl start.
	self assert: component thread isRunning.
	
	10 milliSecond wait.
	MolComponentManager cleanUp.
	
	"waiting for thread loop"
	5 second wait. "here no error"
	self deny: component thread isRunning
]

{ #category : #tests }
MolComponentImplTest >> testServicesDoIfNone [

	| component exception |
	"First: with found services"
	component := MolUtils startComponent: MolCompleteComponentImpl.
	component getMolUsedServicesProvider servicesDo: [ :s | 
		self assert: s isFoundServices.
		self assert: s service equals: #service.
	] ifNone: [ self fail ].

	"Second: with not found services"
	component := MolCompleteComponentImpl new.
	component getMolUsedServicesProvider servicesDo: [ :s | self fail ] ifNone: [ 
		exception := true.
	].
	self assert: exception.
]

{ #category : #tests }
MolComponentImplTest >> testServicesProviders [

	| component |
	
	component := MolCompleteComponentImpl new.
	
	self assert: component servicesProviders isEmpty.
	
	component := MolUtils deployAndInitializeComponent: MolCompleteComponentImpl named: #myComponentA.
	
	"Test initial events producer contents : default component name"
	self assert: component servicesProviders size equals: 1.
	self assert: (component servicesProviders at: MolUsedServices) equals: MolUtils defaultComponentName.
	
	MolUtils activateComponent: MolCompleteComponentImpl named: #myComponentA.
	
	self assert: component servicesProviders size equals: 1.
	self assert: (component servicesProviders at: MolUsedServices) equals: MolUtils defaultComponentName.
	
	MolUtils passivateComponent: MolCompleteComponentImpl named: #myComponentA.
	
	self assert: component servicesProviders size equals: 1.
	self assert: (component servicesProviders at: MolUsedServices) equals: MolUtils defaultComponentName.
	
	MolUtils removeComponent: MolCompleteComponentImpl named: #myComponentA.

	self assert: component servicesProviders isEmpty.
]

{ #category : #'tests - component creation' }
MolComponentImplTest >> testStart [

	MolCompleteComponentImpl deploy.
	MolCompleteComponentImpl instantiate.
	self assert: (MolUtils instanceOf: MolCompleteComponentImpl) notNil.
	MolCompleteComponentImpl activate.
	MolCompleteComponentImpl passivate.
	MolCompleteComponentImpl remove.
	self assert: (MolUtils instanceOf: MolCompleteComponentImpl) isNil.
	MolCompleteComponentImpl undeploy
]

{ #category : #'tests - component creation' }
MolComponentImplTest >> testStart2 [
	| component |
	component := MolCompleteComponentImpl start.
	self assert: (MolUtils instanceOf: MolCompleteComponentImpl) notNil.
	self assert: component isComponent.
	self assert: component componentName equals: MolUtils defaultComponentName.
	
	component := MolCompleteComponentImpl start: #compA.
	self assert: (MolUtils instanceOf: MolCompleteComponentImpl named: #compA) notNil.
	self assert: component isComponent.
	self assert: component componentName equals: #compA.
]

{ #category : #'tests - component creation' }
MolComponentImplTest >> testStartWithGeneratedName [

	| instance instance2 |
	instance := MolCompleteComponentImpl startWithGeneratedName.
	self assert: instance componentName notNil.
	self assert: instance componentName isSymbol.
	
	instance2 := MolCompleteComponentImpl startWithGeneratedName.
	self assert: instance2 componentName notNil.
	self assert: instance2 componentName isSymbol.
	self deny: instance componentName equals: instance2 componentName.
	
]

{ #category : #'tests - component creation' }
MolComponentImplTest >> testStartWithName [

	MolCompleteComponentImpl deploy.
	MolCompleteComponentImpl instantiate: #myComponent.
	self assert: (MolUtils instanceOf: MolCompleteComponentImpl named: #myComponent) notNil.
	MolCompleteComponentImpl activate: #myComponent.
	MolCompleteComponentImpl passivate: #myComponent.
	MolCompleteComponentImpl remove: #myComponent.
	self assert: (MolUtils instanceOf: MolCompleteComponentImpl named: #myComponent) isNil.
	MolCompleteComponentImpl undeploy
]

{ #category : #'tests - component creation' }
MolComponentImplTest >> testStartWithWrongNames [
	"Start component with different types of component name"
	| component error |
	
	[component := MolCompleteComponentImpl start: 'myComponentName'] on: Error do:[ :e |
		error := e.
	].
	self assert: (error isKindOf: WrongComponentNameError).
	self assert: component isNil.

	error := nil.
	[component := MolCompleteComponentImpl start: 12] on: Error do:[ :e |
		error := e.
	].
	self assert: (error isKindOf: WrongComponentNameError).
	self assert: component isNil.

	error := nil.	
	[component := MolCompleteComponentImpl start: (OrderedCollection new)] on: Error do:[ :e |
		error := e.
	].
	self assert: (error isKindOf: WrongComponentNameError).
	self assert: component isNil.

	error := nil.	
	[component := MolCompleteComponentImpl start: nil] on: Error do:[ :e |
		error := e.
	].
	self assert: (error isKindOf: WrongComponentNameError).
	self assert: component isNil.
]

{ #category : #'tests - component creation' }
MolComponentImplTest >> testStop [

	MolCompleteComponentImpl start.
	MolCompleteComponentImpl stop.
	self assert: (MolUtils instanceOf: MolCompleteComponentImpl) equals: nil.
	
	MolCompleteComponentImpl start: #compA.
	MolCompleteComponentImpl stop: #compA.
	self assert: (MolUtils instanceOf: MolCompleteComponentImpl named: #compA) equals: nil.
	
]

{ #category : #'tests - component creation' }
MolComponentImplTest >> testStopInstance [

	| instance |
	instance := MolCompleteComponentImpl start.
	instance stop.
	self assert: (MolUtils instanceOf: MolCompleteComponentImpl) equals: nil.
	
	instance := MolCompleteComponentImpl start: #test.
	instance stop.
	self assert: (MolUtils instanceOf: MolCompleteComponentImpl) equals: nil.
]