}

    def "nothing subscribed when no actions registered"() {
        expect:
        !r.isSubscribed(null)
        !r.isSubscribed(CharSequence)
        !r.isSubscribed(String)
    }

    def "actions are invoked in order registered"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)

        given:
        r.registerEagerAddAction(String, action1)
        r.registerEagerAddAction(String, action2)

	deletionGracePeriod := int64(10)
	terminationGracePeriod := int64(10)
	lifecycle := &v1.Lifecycle{
		// Left PostStart as nil
		PreStop: &v1.LifecycleHandler{
			Exec: &v1.ExecAction{
				Command: []string{"action1", "action2"},
			},
			HTTPGet: &v1.HTTPGetAction{
				Path:   "path",
				Host:   "host",
				Port:   intstr.FromInt32(8080),
				Scheme: "scheme",
			},
			TCPSocket: &v1.TCPSocketAction{

        1 * action1.execute(project)
        1 * action2.execute(project)
        0 * _._
    }

    def "does not continue executing actions when action fails"() {
        def project = Mock(ProjectInternal)
        def failure = new RuntimeException("Configure action failed")

        when:
        evaluator.evaluate(project, state)

        then:
        1 * action1.execute(project) >> {
            throw failure

        then:
        1 * action.execute({it != null})
        0 * action._
    }

    def "executes action against an Ivy instance and returns the result"() {
        def action = Mock(Transformer)

        when:
        def result = manager.withIvy(action)

        then:
        result == "result"

        and:
        1 * action.transform({it != null}) >> "result"
        0 * action._
    }

                def release1 = cacheAccess.acquireFileLock()
                thread.blockUntil.action2
                release1.run()
                instant.action1
            }
            start {
                def release2 = cacheAccess.acquireFileLock()
                instant.action2
                thread.blockUntil.action1
                release2.run()
            }
        }

        then:

        given:
        def action1 = {
            instant.action1Start
            thread.block()
            instant.action1End
        }
        def action2 = {
            instant.action2Start
        }

        when:
        start {
            synchronizer.runNow(action1)
        }
        async {
            thread.blockUntil.action1Start

        then:
        result.getModel() == model
    }

    def "runs supplied actions"() {
        def action1 = Mock(Supplier)
        def action2 = Mock(Supplier)
        def action3 = Mock(Supplier)

        when:
        def result = controller.run([action1, action2, action3])

        then:
        result == ["one", "two", "three"]

github-actions-workflows.png...

Sebastián Ramírez <******@****.***> 1603648476 +0100

	}
	d.finalizeNamespace(context.Background(), testNamespace)
	actions := mockClient.Actions()
	if len(actions) != 1 {
		t.Errorf("Expected 1 mock client action, but got %v", len(actions))
	}
	if !actions[0].Matches("create", "namespaces") || actions[0].GetSubresource() != "finalize" {
		t.Errorf("Expected finalize-namespace action %v", actions[0])
	}
	finalizers := actions[0].(core.CreateAction).GetObject().(*v1.Namespace).Spec.Finalizers