github.com/mcuadros/ascode@v1.3.1/starlark/types/testdata/resource.star (about)

     1  load("assert.star", "assert")
     2  
     3  ignition = tf.provider("ignition", "1.1.0")
     4  
     5  
     6  
     7  # attr
     8  qux = ignition.data.user()
     9  qux.uid = 42
    10  assert.eq(qux.uid, 42)
    11  
    12  qux.uid *= 2
    13  assert.eq(qux.uid, 84)
    14  
    15  # attr names 
    16  assert.eq("uid" in dir(qux), True)
    17  
    18  # attr names in data sources
    19  assert.eq("depends_on" in dir(qux), False)
    20  assert.eq("add_provisioner" in dir(qux), False)
    21  assert.eq("__provider__" in dir(qux), True)
    22  assert.eq("__type__" in dir(qux), True)
    23  assert.eq("__name__" in dir(qux), True)
    24  assert.eq("__kind__" in dir(qux), True)
    25  assert.eq("__dict__" in dir(qux), True)
    26  
    27  # attr not-set
    28  assert.eq(qux.name, None)
    29  
    30  # attr not-exists
    31  assert.fails(lambda: qux.foo, "Resource<data> has no .foo field or method")
    32  
    33  # attr id
    34  assert.eq(type(qux.id), "Attribute<string>")
    35  assert.eq(str(qux.id), "${data.ignition_user.id_2.id}")
    36  aws = tf.provider("aws", "2.13.0")
    37  
    38  # attr output assignation
    39  def invalidOutput(): aws.data.instance().public_dns = "foo"
    40  assert.fails(invalidOutput, "Resource<aws.data.aws_instance>: can't set computed public_dns attribute")
    41  
    42  
    43  # attr output in asignation
    44  web = aws.resource.instance()
    45  web.ami = web.id
    46  def invalidType(): web.get_password_data = web.id
    47  assert.fails(invalidType, "expected bool, got string")
    48  
    49  group = aws.resource.autoscaling_group()
    50  
    51  # attr names in resources
    52  assert.eq("depends_on" in dir(web), True)
    53  assert.eq("add_provisioner" in dir(web), True)
    54  assert.eq("__provider__" in dir(web), True)
    55  assert.eq("__type__" in dir(web), True)
    56  assert.eq("__name__" in dir(web), True)
    57  assert.eq("__kind__" in dir(web), True)
    58  assert.eq("__dict__" in dir(web), True)
    59  
    60  # attr optional computed
    61  assert.eq(str(group.name), "${aws_autoscaling_group.id_6.name}")
    62  
    63  group.name = "foo"
    64  assert.eq(group.name, "foo")
    65  
    66  # attr resource
    67  group.mixed_instances_policy = {
    68      "launch_template": {
    69          "launch_template_specification": {
    70              "launch_template_id": "bar",
    71          },
    72      },
    73  }
    74  
    75  assert.eq(group.mixed_instances_policy.launch_template.launch_template_specification.launch_template_id, "bar")
    76  
    77  # attr collections
    78  assert.eq("__provider__" in dir(web.network_interface), True)
    79  assert.eq("__type__" in dir(web.network_interface), True)
    80  assert.eq("__kind__" in dir(web.network_interface), True)
    81  
    82  web.network_interface = [
    83      {"network_interface_id": "foo"},
    84      {"network_interface_id": "bar"},
    85  ]
    86  
    87  assert.eq(len(web.network_interface), 2)
    88  assert.eq(web.network_interface[0].network_interface_id, "foo")
    89  assert.eq(web.network_interface[1].network_interface_id, "bar")
    90  
    91  # attr collections clears list
    92  web.network_interface = [
    93      {"network_interface_id": "qux"},
    94  ]
    95  
    96  assert.eq(len(web.network_interface), 1)
    97  assert.eq(web.network_interface[0].network_interface_id, "qux")
    98  
    99  # attr collection non list
   100  def attrCollectionNonList(): web.network_interface = {}
   101  assert.fails(attrCollectionNonList, "expected list, got dict")
   102  
   103  # attr collection non dict elements
   104  def attrCollectionNonDictElement(): web.network_interface = [{}, 42]
   105  assert.fails(attrCollectionNonDictElement, "1: expected dict, got int")
   106  
   107  # comparasion simple values
   108  assert.eq(ignition.data.disk(), ignition.data.disk())
   109  assert.ne(ignition.data.disk(device="foo"), ignition.data.disk())
   110  
   111  # comparasion with nested
   112  y = ignition.data.disk()
   113  x = ignition.data.disk()
   114  
   115  y.partition(start=42)
   116  assert.ne(x, y)
   117  
   118  x.partition(start=42)
   119  assert.eq(x, y)
   120  
   121  # comparasion with list
   122  assert.ne(ignition.data.user(groups=["foo"]), ignition.data.user())
   123  assert.eq(ignition.data.user(groups=["foo"]), ignition.data.user(groups=["foo"]))
   124  
   125  # constructor with name
   126  quux = ignition.data.user("quux")
   127  assert.eq(str(quux.id), "${data.ignition_user.quux.id}")
   128  
   129  # constructor from kwargs
   130  bar = ignition.data.user(uid=42, system=True)
   131  assert.eq(bar.uid, 42)
   132  assert.eq(bar.system, True)
   133  
   134  # constructor from kwargs with name
   135  fred = ignition.data.user("fred", uid=42, system=True)
   136  assert.eq(fred.uid, 42)
   137  assert.eq(fred.system, True)
   138  assert.eq(str(fred.id), "${data.ignition_user.fred.id}")
   139  
   140  # constructor from dict
   141  foo = ignition.data.user({"uid": 42, "system": True})
   142  assert.eq(foo.uid, 42)
   143  assert.eq(foo.system, True)
   144  
   145  # constructor from dict with name
   146  baz = ignition.data.user("baz", {"uid": 42, "system": True})
   147  assert.eq(baz.uid, 42)
   148  assert.eq(baz.system, True)
   149  assert.eq(str(baz.id), "${data.ignition_user.baz.id}")
   150  
   151  # constructor from dict with name and kwargs
   152  baz = ignition.data.user("baz", {"uid": 42, "system": True}, uid=84)
   153  assert.eq(baz.uid, 84)
   154  assert.eq(baz.system, True)
   155  assert.eq(str(baz.id), "${data.ignition_user.baz.id}")
   156  
   157  
   158  assert.eq(bar, foo)
   159  assert.eq(foo, ignition.data.user(foo.__dict__))
   160  
   161  # constructor errors
   162  def consNonDict(): ignition.data.user(1)
   163  assert.fails(consNonDict, "resource: expected string or dict, got int")
   164  
   165  def consNonNameDict(): ignition.data.user(1, 1)
   166  assert.fails(consNonNameDict, "resource: expected string, got int")
   167  
   168  def consNameDict(): ignition.data.user("foo", 1)
   169  assert.fails(consNameDict, "resource: expected dict, got int")
   170  
   171  def consKwargsNonName(): ignition.data.user(1, uid=42)
   172  assert.fails(consKwargsNonName, "resource: expected string or dict, got int")
   173  
   174  # full coverage
   175  user = ignition.data.user()
   176  user.name = "foo"
   177  user.uid = 42
   178  user.groups = ["foo", "bar"]
   179  user.system = True
   180  
   181  assert.eq(str(user), "Resource<ignition.data.ignition_user>")
   182  assert.eq(user.__dict__, {
   183      "name": "foo",
   184      "uid": 42,
   185      "groups": ["foo", "bar"],
   186      "system": True,
   187  })
   188  
   189  disk = ignition.data.disk()
   190  
   191  root = disk.partition()
   192  root.label = "root"
   193  root.start = 2048
   194  root.size = 4 * 1024 * 1024
   195  
   196  home = disk.partition()
   197  home.label = "home"
   198  home.start = root.size + root.start
   199  home.size = 4 * 1024 * 1024
   200  
   201  assert.eq(disk.__dict__, {
   202      "partition": [{
   203          "label": "root",
   204          "start": 2048,
   205          "size": 4194304
   206      }, {
   207          "start": 4196352,
   208          "size": 4194304,
   209          "label": "home"
   210      }]
   211  })
   212  
   213  
   214  # depends_on
   215  instanceA = aws.resource.instance()
   216  instanceB = aws.resource.instance()
   217  instanceA.depends_on(instanceB)
   218  
   219  def dependsOnNonResource(): instanceA.depends_on(42)
   220  assert.fails(dependsOnNonResource, "expected Resource<\\[data|resource\\]>, got int")
   221  
   222  def dependsOnNestedResource(): instanceA.depends_on(disk.partition())
   223  assert.fails(dependsOnNestedResource, "expected Resource<\\[data|resource\\]>, got Resource<nested.partition>")
   224  
   225  def dependsOnItself(): instanceA.depends_on(instanceA)
   226  assert.fails(dependsOnItself, "can't depend on itself")
   227  
   228  # __provider__
   229  assert.eq(web.__provider__, aws)
   230  assert.eq(baz.__provider__, ignition)
   231  assert.eq(instanceA.__provider__, aws)
   232  assert.eq(home.__provider__, ignition)
   233  assert.eq(aws.resource.instance.__provider__, aws)
   234  
   235  # __kind__
   236  assert.eq(ignition.data.user().__kind__, "data")
   237  assert.eq(aws.resource.instance.__kind__, "resource")
   238  assert.eq(aws.resource.instance().__kind__, "resource")
   239  assert.eq(aws.resource.autoscaling_group().mixed_instances_policy.__kind__, "nested")
   240  assert.eq(web.network_interface.__kind__, "nested")
   241  
   242  # __type__
   243  assert.eq(ignition.data.user().__type__, "ignition_user")
   244  assert.eq(aws.resource.instance.__type__, "aws_instance")
   245  assert.eq(aws.resource.instance().__type__, "aws_instance")
   246  assert.eq(aws.resource.autoscaling_group().mixed_instances_policy.__type__, "mixed_instances_policy")
   247  assert.eq(web.network_interface.__type__, "network_interface")
   248  
   249  # __name__
   250  assert.eq(ignition.data.user().__name__, "id_30")
   251  assert.eq(aws.resource.instance().__name__, "id_31")
   252  assert.eq(ignition.data.user("given").__name__, "given")
   253  
   254  # __call__
   255  assert.eq(ignition.data.user().__name__, "id_32")
   256  assert.eq(ignition.data.user("foo").__name__, "foo")
   257  assert.eq(ignition.data.user(uid=42).uid, 42)
   258  assert.eq(ignition.data.user({"uid": 42}).uid, 42)
   259  
   260  foo = ignition.data.user("foo", {"uid": 42})
   261  assert.eq(foo.__name__, "foo")
   262  assert.eq(foo.uid, 42)
   263  
   264  foo = ignition.data.user("foo", uid=42)
   265  assert.eq(foo.__name__, "foo")
   266  assert.eq(foo.uid, 42)