How to use the taskcat._cfn.stack.Stack.create function in taskcat

def test_delete(self, _, __):
        region = make_test_region_obj("us-west-2")
        m_template = make_test_template()
        stack = Stack.create(region, "stack_name", m_template)
        stack._timer.cancel()
        stack.client = mock.Mock()

        stack.refresh.reset_mock()
        stack.delete(client=stack.client, stack_id=stack.id)
        stack.client.delete_stack.assert_called_once()

def test_events(self, m_eve, _):
        region = make_test_region_obj("us-west-2")
        m_template = make_test_template()
        stack = Stack.create(region, "stack_name", m_template)
        stack._timer.cancel()
        generic_evnt = event_template.copy()
        not_generic_evnt = event_template.copy()
        generic_evnt["ResourceStatusReason"] = "Resource creation cancelled"
        generic_evnt["LogicalResourceId"] = "generic"
        not_generic_evnt["LogicalResourceId"] = "not-generic"
        stack._events = Events([Event(generic_evnt), Event(not_generic_evnt)])

        actual = stack.events()
        m_eve.assert_called_once()
        self.assertEqual(len(actual), 2)

        stack._last_event_refresh = datetime.now()
        actual = stack.events(include_generic=False)
        m_eve.assert_called_once()
        self.assertEqual(len(actual), 1)

def test_descentants(self, m_evnts, __):
        region = make_test_region_obj("us-west-2")
        region.client = mock_client_method
        test_proj = (Path(__file__).parent / "./data/nested-fail").resolve()
        c = Config.create(
            project_config_path=test_proj / ".taskcat.yml", project_root=test_proj
        )
        templates = c.get_templates(project_root=test_proj)
        stack = Stack.create(region, "stack_name", templates["taskcat-json"])
        stack._timer.cancel()

        child = event_template.copy()
        grandchild = event_template.copy()
        child["PhysicalResourceId"] = (
            "arn:aws:cloudformation:us-east-1:123456789012:"
            "stack/Child/e722ae60-fe62-11e8-9a0e-0ae8cc519969"
        )
        child["ResourceProperties"] = (
            '{"TemplateURL": "https://test.s3.amazonaws.com/templates/'
            'test.template_inner.yaml"}'
        )
        grandchild["PhysicalResourceId"] = (
            "arn:aws:cloudformation:us-east-1:123456789012:stack/GrandChild/"
            "e722ae60-fe62-11e8-9a0e-0ae8cc519970"
        )

def test_refresh(self, m_kids, m_res, m_eve, m_prop, _):
        region = make_test_region_obj("us-west-2")
        m_template = make_test_template()
        stack = Stack.create(region, "stack_name", m_template)
        stack._timer.cancel()

        m_prop.reset_mock()
        stack.refresh()
        m_prop.assert_called_once()
        m_res.assert_not_called()
        m_eve.assert_not_called()
        m_kids.assert_not_called()

        m_prop.reset_mock()
        stack.refresh(properties=False, events=True)
        m_eve.assert_called_once()
        m_res.assert_not_called()
        m_prop.assert_not_called()
        m_kids.assert_not_called()

def test_resources(self, m_res, _):
        region = make_test_region_obj("us-west-2")
        m_template = make_test_template()
        stack = Stack.create(region, "stack_name", m_template)
        stack._timer.cancel()
        stack._resources = Resources([Resource("test_stack_id", resource_template)])

        stack.resources()
        m_res.assert_called_once()

        stack._last_resource_refresh = datetime.now()
        stack.resources()
        m_res.assert_called_once()

        m_res.reset_mock()
        stack.resources(refresh=True)
        m_res.assert_called_once()

def test_idempotent_properties(self, _):
        region = make_test_region_obj("us-west-2")
        region.client = mock_client_method
        m_template = make_test_template()
        stack = Stack.create(region, "stack_name", m_template)
        stack._timer.cancel()
        no_outp = len(stack.outputs)
        no_params = len(stack.parameters)
        no_tags = len(stack.tags)
        # re-invoke timer function manually to check for idempotence
        stack.set_stack_properties()
        stack._timer.cancel()
        self.assertEqual(len(stack.outputs), no_outp)
        self.assertEqual(len(stack.parameters), no_params)
        self.assertEqual(len(stack.tags), no_tags)

def test_create(self, m_s3_url_maker):
        region = make_test_region_obj("us-west-2")
        template = make_test_template()
        stack = Stack.create(region, "stack_name", template)
        self.assertIsInstance(stack._timer, Timer)
        # disabled due to a concurrency issue with the tests
        # self.assertEqual(stack._timer.is_alive(), True)
        stack._timer.cancel()
        m_s3_url_maker.assert_called_once()
        self.assertNotEquals(template, stack.template)

def test_fetch_stack_resources(self, _, __):
        region = make_test_region_obj("us-west-2")
        m_template = make_test_template()
        stack = Stack.create(region, "stack_name", m_template)
        stack._timer.cancel()
        stack.client = mock.Mock()

        class Paging:
            @staticmethod
            def paginate(**kwargs):
                return [
                    {
                        "StackResourceSummaries": [
                            {
                                "StackId": "arn:aws:cloudformation:us-east-1:"
                                "123456789012:stack/"
                                "SampleStack/e722ae60-fe62-11e8-9a0e-0ae8cc519968"
                            }
                        ]
                    }

def _create_stacks_for_test(self, test, tags, threads: int = 32):
        prefix = f"{self.stack_name_prefix}-" if self.stack_name_prefix else ""
        stack_name = "{}{}-{}-{}".format(
            prefix, self.project_name, test.name, self.uid.hex
        )
        tags.append(Tag({"Key": "taskcat-project-name", "Value": self.project_name}))
        tags.append(Tag({"Key": "taskcat-test-name", "Value": test.name}))
        partial_kwargs = {
            "stack_name": stack_name,
            "template": test.template,
            "tags": tags,
            "test_name": test.name,
        }
        stacks = fan_out(Stack.create, partial_kwargs, test.regions, threads)
        self.stacks += stacks