@alloy-js/python 0.0.1

package/dist/test/memberexpressions.test.js

@@ -0,0 +1,879 @@
+import { createComponent as _$createComponent, memo as _$memo, createIntrinsic as _$createIntrinsic } from "@alloy-js/core/jsx-runtime";
+import { code, memberRefkey, refkey } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { describe, expect, it } from "vitest";
+import * as py from "../src/index.js";
+import { ClassDeclaration, FunctionDeclaration, SourceFile, VariableDeclaration } from "../src/index.js";
+import { assertFileContents, toSourceText, toSourceTextMultiple } from "./utils.js";
+it("renders basic member expression with dot notation", () => {
+  expect(toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "obj"
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "property"
+      })];
+    }
+  })])).toBe(d`
+    obj.property
+  `);
+});
+it("renders basic member expression with key", () => {
+  expect(toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "arr"
+      }), _$createComponent(py.MemberExpression.Part, {
+        key: 12345
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "foo-bar"
+      })];
+    }
+  })])).toBe(d`
+    arr[12345].foo-bar
+  `);
+});
+it("renders basic member expression with key with reference", () => {
+  const rk1 = refkey();
+  expect(toSourceText([_$createComponent(py.StatementList, {
+    get children() {
+      return [_$createComponent(py.VariableDeclaration, {
+        name: "test1",
+        refkey: rk1,
+        initializer: 1
+      }), _$createComponent(py.MemberExpression, {
+        get children() {
+          return [_$createComponent(py.MemberExpression.Part, {
+            id: "arr"
+          }), _$createComponent(py.MemberExpression.Part, {
+            key: rk1
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "foo-bar"
+          })];
+        }
+      })];
+    }
+  })])).toBe(d`
+    test1 = 1
+    arr[test1].foo-bar
+  `);
+});
+it("renders basic member expression with keys", () => {
+  expect(toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "arr"
+      }), _$createComponent(py.MemberExpression.Part, {
+        keys: [1, 2]
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "foo-bar"
+      })];
+    }
+  })])).toBe(d`
+    arr[1, 2].foo-bar
+  `);
+});
+it("renders basic member expression with keys with references", () => {
+  const rk1 = refkey();
+  const rk2 = refkey();
+  expect(toSourceText([_$createComponent(py.StatementList, {
+    get children() {
+      return [_$createComponent(py.VariableDeclaration, {
+        name: "test1",
+        refkey: rk1,
+        initializer: 1
+      }), _$createComponent(py.VariableDeclaration, {
+        name: "test2",
+        refkey: rk2,
+        initializer: 2
+      }), _$createComponent(py.MemberExpression, {
+        get children() {
+          return [_$createComponent(py.MemberExpression.Part, {
+            id: "arr"
+          }), _$createComponent(py.MemberExpression.Part, {
+            keys: [rk1, rk2]
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "foo-bar"
+          })];
+        }
+      })];
+    }
+  })])).toBe(d`
+    test1 = 1
+    test2 = 2
+    arr[test1, test2].foo-bar
+  `);
+});
+it("renders basic member expression with slice - 1", () => {
+  expect(toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "arr"
+      }), _$createComponent(py.MemberExpression.Part, {
+        slice: {
+          start: 1,
+          stop: 3,
+          step: 2
+        }
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "foo-bar"
+      })];
+    }
+  })])).toBe(d`
+    arr[1:3:2].foo-bar
+  `);
+});
+it("renders basic member expression with slice - 1 with references", () => {
+  const rk1 = refkey();
+  const rk2 = refkey();
+  const rk3 = refkey();
+  expect(toSourceText([_$createComponent(py.StatementList, {
+    get children() {
+      return [_$createComponent(py.VariableDeclaration, {
+        name: "test1",
+        refkey: rk1,
+        initializer: 1
+      }), _$createComponent(py.VariableDeclaration, {
+        name: "test2",
+        refkey: rk2,
+        initializer: 3
+      }), _$createComponent(py.VariableDeclaration, {
+        name: "test3",
+        refkey: rk3,
+        initializer: 2
+      }), _$createComponent(py.MemberExpression, {
+        get children() {
+          return [_$createComponent(py.MemberExpression.Part, {
+            id: "arr"
+          }), _$createComponent(py.MemberExpression.Part, {
+            slice: {
+              start: rk1,
+              stop: rk2,
+              step: rk3
+            }
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "foo-bar"
+          })];
+        }
+      })];
+    }
+  })])).toBe(d`
+    test1 = 1
+    test2 = 3
+    test3 = 2
+    arr[test1:test2:test3].foo-bar
+  `);
+});
+it("renders basic member expression with slice - 2", () => {
+  expect(toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "arr"
+      }), _$createComponent(py.MemberExpression.Part, {
+        slice: {
+          stop: 3
+        }
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "foo-bar"
+      })];
+    }
+  })])).toBe(d`
+    arr[:3].foo-bar
+  `);
+});
+it("renders basic member expression with slice - 3", () => {
+  expect(toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "arr"
+      }), _$createComponent(py.MemberExpression.Part, {
+        slice: {
+          step: 2
+        }
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "foo-bar"
+      })];
+    }
+  })])).toBe(d`
+    arr[::2].foo-bar
+  `);
+});
+it("renders basic member expression with slice - 4", () => {
+  expect(toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "arr"
+      }), _$createComponent(py.MemberExpression.Part, {
+        slice: {
+          start: 1
+        }
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "foo-bar"
+      })];
+    }
+  })])).toBe(d`
+    arr[1:].foo-bar
+  `);
+});
+it("renders basic member expression with slice - 5", () => {
+  expect(toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "arr"
+      }), _$createComponent(py.MemberExpression.Part, {
+        slice: {
+          start: 1,
+          step: 2
+        }
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "foo-bar"
+      })];
+    }
+  })])).toBe(d`
+    arr[1::2].foo-bar
+  `);
+});
+it("renders basic member expression with an expression index - 1", () => {
+  const xRefkey = refkey();
+  expect(toSourceText([_$createComponent(py.StatementList, {
+    get children() {
+      return [_$createComponent(py.VariableDeclaration, {
+        name: "x",
+        initializer: 1,
+        refkey: xRefkey
+      }), _$createComponent(py.MemberExpression, {
+        get children() {
+          return [_$createComponent(py.MemberExpression.Part, {
+            id: "arr"
+          }), _$createComponent(py.MemberExpression.Part, {
+            key: code`${xRefkey} + 1`
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "foo-bar"
+          })];
+        }
+      })];
+    }
+  })])).toBe(d`
+    x = 1
+    arr[x + 1].foo-bar
+  `);
+});
+it("renders basic member expression with an expression index - 2", () => {
+  expect(toSourceText([_$createComponent(py.StatementList, {
+    get children() {
+      return _$createComponent(py.MemberExpression, {
+        get children() {
+          return [_$createComponent(py.MemberExpression.Part, {
+            id: "arr"
+          }), _$createComponent(py.MemberExpression.Part, {
+            key: code`"foo" + 1`
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "foo-bar"
+          })];
+        }
+      });
+    }
+  })])).toBe(d`
+    arr["foo" + 1].foo-bar
+  `);
+});
+it("throws an error for invalid identifiers with quotes", () => {
+  expect(() => toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "obj"
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: `property-"name"`
+      })];
+    }
+  })])).toThrowError(/Invalid identifier: property-"name"/);
+});
+it("supports multiple levels of nesting", () => {
+  expect(toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "a"
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "b"
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "c"
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "d"
+      })];
+    }
+  })])).toBe(d`
+    a.b.c.d
+  `);
+});
+it("handles a mix of dot and bracket notation", () => {
+  expect(toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "obj"
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "normalProp"
+      }), _$createComponent(py.MemberExpression.Part, {
+        key: "special-prop"
+      }), _$createComponent(py.MemberExpression.Part, {
+        key: "123"
+      })];
+    }
+  })])).toBe(d`
+    obj.normalProp["special-prop"]["123"]
+  `);
+});
+it("throws an error when providing conflicting part props", () => {
+  expect(() => toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "obj"
+      }), _$createComponent(py.MemberExpression.Part, {
+        id: "property",
+        args: [1, 2]
+      })];
+    }
+  })])).toThrowError(`Only one of args, id can be used for a MemberExpression part at a time`);
+});
+it("throws an error when providing an empty slice", () => {
+  expect(() => toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "obj"
+      }), _$createComponent(py.MemberExpression.Part, {
+        slice: {}
+      })];
+    }
+  })])).toThrowError(`MemberExpression.Part: slice object cannot be empty`);
+});
+it("throws an error when providing an empty array", () => {
+  expect(() => toSourceText([_$createComponent(py.MemberExpression, {
+    get children() {
+      return [_$createComponent(py.MemberExpression.Part, {
+        id: "obj"
+      }), _$createComponent(py.MemberExpression.Part, {
+        keys: []
+      })];
+    }
+  })])).toThrowError(`MemberExpression.Part: keys array cannot be empty`);
+});
+it("takes children for the id part", () => {
+  expect(toSourceText([_$createComponent(py.StatementList, {
+    get children() {
+      return [_$createComponent(py.MemberExpression, {
+        get children() {
+          return [_$createComponent(py.MemberExpression.Part, {
+            id: "child1"
+          }), _$createComponent(py.MemberExpression.Part, {
+            key: "child1"
+          })];
+        }
+      }), _$createComponent(py.MemberExpression, {
+        get children() {
+          return [_$createComponent(py.MemberExpression.Part, {
+            id: "child1"
+          }), _$createComponent(py.MemberExpression.Part, {
+            key: "child2"
+          }), _$createComponent(py.MemberExpression.Part, {
+            args: true
+          }), _$createComponent(py.MemberExpression.Part, {
+            key: "child3"
+          }), _$createComponent(py.MemberExpression.Part, {
+            args: true
+          }), _$createComponent(py.MemberExpression.Part, {
+            key: code`"foo" + 1`
+          }), _$createComponent(py.MemberExpression.Part, {
+            args: true
+          })];
+        }
+      })];
+    }
+  })])).toBe(d`
+    child1["child1"]
+    child1["child2"]()["child3"]()["foo" + 1]()
+  `);
+});
+describe("with refkeys", () => {
+  it("handles symbols correctly", () => {
+    const rk1 = refkey();
+    const rk2 = refkey();
+    expect(toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.VariableDeclaration, {
+          name: "test1",
+          refkey: rk1,
+          initializer: 1
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "test1",
+          refkey: rk2,
+          initializer: 2
+        }), _$createComponent(py.MemberExpression, {
+          get children() {
+            return [_$createComponent(py.MemberExpression.Part, {
+              refkey: rk1
+            }), _$createComponent(py.MemberExpression.Part, {
+              refkey: rk2
+            })];
+          }
+        })];
+      }
+    })])).toBe(d`
+        test1 = 1
+        test1_2_test = 2
+        test1.test1_2_test
+      `);
+  });
+  it("Correctly resolves member expressions from 2 different classes", () => {
+    const model1Ref = refkey();
+    const model2Ref = refkey();
+    const classMethod1Ref = refkey();
+    const classMethod2Ref = refkey();
+    const v1Rk = refkey();
+    const v2Rk = refkey();
+    const template = _$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(ClassDeclaration, {
+          name: "Model1",
+          refkey: model1Ref,
+          get children() {
+            return _$createComponent(VariableDeclaration, {
+              name: "foo",
+              refkey: classMethod1Ref,
+              type: "str",
+              omitNone: true,
+              instanceVariable: true
+            });
+          }
+        }), _$createComponent(ClassDeclaration, {
+          name: "Model2",
+          refkey: model2Ref,
+          get children() {
+            return _$createComponent(VariableDeclaration, {
+              name: "bar",
+              refkey: classMethod2Ref,
+              type: "str",
+              omitNone: true,
+              instanceVariable: true
+            });
+          }
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "model1_instance",
+          refkey: v1Rk,
+          type: model1Ref,
+          get initializer() {
+            return _$createComponent(py.MemberExpression, {
+              get children() {
+                return [_$createComponent(py.MemberExpression.Part, {
+                  refkey: model1Ref
+                }), _$createComponent(py.MemberExpression.Part, {
+                  args: true
+                })];
+              }
+            });
+          }
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "model2_instance",
+          refkey: v2Rk,
+          type: model2Ref,
+          get initializer() {
+            return _$createComponent(py.MemberExpression, {
+              get children() {
+                return [_$createComponent(py.MemberExpression.Part, {
+                  refkey: model2Ref
+                }), _$createComponent(py.MemberExpression.Part, {
+                  args: true
+                })];
+              }
+            });
+          }
+        }), [_$memo(() => memberRefkey(v1Rk, classMethod1Ref))], [_$memo(() => memberRefkey(v2Rk, classMethod2Ref))]];
+      }
+    });
+    expect(toSourceText([template])).toBe(d`
+      class Model1:
+          foo: str
+
+      class Model2:
+          bar: str
+
+      model1_instance: Model1 = Model1()
+      model2_instance: Model2 = Model2()
+      model1_instance.foo
+      model2_instance.bar
+    `);
+  });
+  it("handles optional parameters correctly", () => {
+    const fooRef = refkey();
+    const modelRef = refkey();
+    const parameters = [{
+      name: "foo",
+      optional: true,
+      refkey: fooRef,
+      type: modelRef
+    }];
+    const messageRef = refkey();
+    const template = _$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(ClassDeclaration, {
+          name: "Model",
+          refkey: modelRef,
+          get children() {
+            return _$createComponent(VariableDeclaration, {
+              name: "bar",
+              get refkey() {
+                return refkey();
+              },
+              type: "str",
+              omitNone: true
+            });
+          }
+        }), _$createComponent(FunctionDeclaration, {
+          name: "fooFunction",
+          parameters: parameters,
+          get children() {
+            return _$createComponent(py.StatementList, {
+              get children() {
+                return [_$createComponent(py.VariableDeclaration, {
+                  name: "message",
+                  refkey: messageRef,
+                  get initializer() {
+                    return _$createComponent(py.MemberExpression, {
+                      get children() {
+                        return [_$createComponent(py.MemberExpression.Part, {
+                          refkey: fooRef
+                        }), _$createComponent(py.MemberExpression.Part, {
+                          id: "bar"
+                        })];
+                      }
+                    });
+                  }
+                }), ["print(", messageRef, ")"]];
+              }
+            });
+          }
+        })];
+      }
+    });
+    expect(toSourceText([template])).toBe(d`
+      class Model:
+          bar: str
+
+      def foo_function(foo: Model = None):
+          message = foo.bar
+          print(message)
+
+    `);
+  });
+  it("handles class member correctly", () => {
+    const classRefkey = refkey();
+    const interfaceRefkey = refkey();
+    const interfaceMemberRefkey = refkey();
+    const classMethodRefkey = refkey();
+    const classMemberRefkey = refkey();
+    const instanceRefkey = refkey();
+    expect(toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(ClassDeclaration, {
+          name: "Bar",
+          refkey: interfaceRefkey,
+          get children() {
+            return _$createComponent(VariableDeclaration, {
+              name: "prop1",
+              refkey: interfaceMemberRefkey,
+              type: "str",
+              omitNone: true
+            });
+          }
+        }), _$createComponent(ClassDeclaration, {
+          name: "Foo",
+          refkey: classRefkey,
+          get children() {
+            return [_$createComponent(VariableDeclaration, {
+              name: "test1",
+              refkey: classMemberRefkey,
+              type: interfaceRefkey
+            }), _$createIntrinsic("br", {}), _$createComponent(FunctionDeclaration, {
+              name: "testMethod",
+              parameters: [],
+              refkey: classMethodRefkey,
+              returnType: interfaceRefkey
+            })];
+          }
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "inst",
+          refkey: instanceRefkey,
+          initializer: code`${classRefkey}()`
+        }), _$createComponent(py.MemberExpression, {
+          get children() {
+            return [_$createComponent(py.MemberExpression.Part, {
+              refkey: instanceRefkey
+            }), _$createComponent(py.MemberExpression.Part, {
+              refkey: classMemberRefkey
+            }), _$createComponent(py.MemberExpression.Part, {
+              refkey: interfaceMemberRefkey
+            })];
+          }
+        }), _$createComponent(py.MemberExpression, {
+          get children() {
+            return [_$createComponent(py.MemberExpression.Part, {
+              refkey: instanceRefkey
+            }), _$createComponent(py.MemberExpression.Part, {
+              refkey: classMethodRefkey
+            }), _$createComponent(py.MemberExpression.Part, {
+              args: []
+            })];
+          }
+        })];
+      }
+    })])).toBe(d`
+       class Bar:
+           prop1: str
+
+       class Foo:
+           test1: Bar = None
+           def test_method() -> Bar:
+               pass
+
+
+       inst = Foo()
+       inst.test1.prop1
+       inst.test_method()
+    `);
+  });
+  it("handles late resolved refkeys correctly", () => {
+    const rk1 = refkey();
+    const rk2 = refkey();
+    expect(toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.MemberExpression, {
+          get children() {
+            return [_$createComponent(py.MemberExpression.Part, {
+              refkey: rk1
+            }), _$createComponent(py.MemberExpression.Part, {
+              refkey: rk2
+            })];
+          }
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "test1",
+          refkey: rk1,
+          initializer: 1
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "test1",
+          refkey: rk2,
+          initializer: 2
+        })];
+      }
+    })])).toBe(d`
+      test1.test1_2_test
+      test1 = 1
+      test1_2_test = 2
+    `);
+  });
+  it("creates a full reference to the first refkey", () => {
+    const rk1 = refkey();
+    const res = toSourceTextMultiple([_$createComponent(SourceFile, {
+      path: "source.py",
+      get children() {
+        return _$createComponent(py.VariableDeclaration, {
+          name: "importMe",
+          refkey: rk1
+        });
+      }
+    }), _$createComponent(SourceFile, {
+      path: "index.py",
+      get children() {
+        return _$createComponent(py.StatementList, {
+          get children() {
+            return _$createComponent(py.MemberExpression, {
+              get children() {
+                return [_$createComponent(py.MemberExpression.Part, {
+                  refkey: rk1
+                }), _$createComponent(py.MemberExpression.Part, {
+                  id: "foo"
+                })];
+              }
+            });
+          }
+        });
+      }
+    })]);
+    assertFileContents(res, {
+      "index.py": d`
+        from source import import_me
+
+        import_me.foo
+      `
+    });
+  });
+});
+describe("with function calls", () => {
+  it("handles simple function calls correctly", () => {
+    expect(toSourceText([_$createComponent(py.MemberExpression, {
+      get children() {
+        return [_$createComponent(py.MemberExpression.Part, {
+          id: "myFunction"
+        }), _$createComponent(py.MemberExpression.Part, {
+          args: [1, 2]
+        })];
+      }
+    })])).toBe(d`
+      myFunction(1, 2)
+    `);
+  });
+  it("handles function calls with references correctly", () => {
+    const xRefkey = refkey();
+    const yRefkey = refkey();
+    expect(toSourceText([_$createComponent(py.StatementList, {
+      get children() {
+        return [_$createComponent(py.VariableDeclaration, {
+          name: "x",
+          initializer: 1,
+          refkey: xRefkey
+        }), _$createComponent(py.VariableDeclaration, {
+          name: "y",
+          initializer: 2,
+          refkey: yRefkey
+        }), _$createComponent(py.MemberExpression, {
+          get children() {
+            return [_$createComponent(py.MemberExpression.Part, {
+              id: "myFunction"
+            }), _$createComponent(py.MemberExpression.Part, {
+              args: [xRefkey, yRefkey]
+            })];
+          }
+        })];
+      }
+    })])).toBe(d`
+      x = 1
+      y = 2
+      myFunction(x, y)
+    `);
+  });
+  it("handles method calls correctly", () => {
+    expect(toSourceText([_$createComponent(py.MemberExpression, {
+      get children() {
+        return [_$createComponent(py.MemberExpression.Part, {
+          id: "method1"
+        }), _$createComponent(py.MemberExpression.Part, {
+          args: [1, 2]
+        }), _$createComponent(py.MemberExpression.Part, {
+          args: []
+        }), _$createComponent(py.MemberExpression.Part, {
+          id: "method2"
+        }), _$createComponent(py.MemberExpression.Part, {
+          args: []
+        }), _$createComponent(py.MemberExpression.Part, {
+          id: "prop"
+        })];
+      }
+    })])).toBe(d`
+      method1(1, 2)().method2().prop
+    `);
+  });
+  it("handles function calls correctly", () => {
+    expect(toSourceText([_$createComponent(py.MemberExpression, {
+      get children() {
+        return [_$createComponent(py.MemberExpression.Part, {
+          id: "myFunction"
+        }), _$createComponent(py.MemberExpression.Part, {
+          args: [1, 2]
+        }), _$createComponent(py.MemberExpression.Part, {
+          id: "prop"
+        })];
+      }
+    })])).toBe(d`
+      myFunction(1, 2).prop
+    `);
+  });
+  it("handles function calls correctly", () => {
+    expect(toSourceText([_$createComponent(py.MemberExpression, {
+      get children() {
+        return [_$createComponent(py.MemberExpression.Part, {
+          id: "myFunction"
+        }), _$createComponent(py.MemberExpression.Part, {
+          args: [1, 2]
+        }), _$createComponent(py.MemberExpression.Part, {
+          id: "prop"
+        })];
+      }
+    })])).toBe(d`
+      myFunction(1, 2).prop
+    `);
+  });
+});
+describe("formatting", () => {
+  describe("simple chains", () => {
+    it("just dots", () => {
+      expect(toSourceText([_$createComponent(py.MemberExpression, {
+        get children() {
+          return [_$createComponent(py.MemberExpression.Part, {
+            id: "four"
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "four"
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "two"
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "two"
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "two"
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "two"
+          })];
+        }
+      })], {
+        printOptions: {
+          printWidth: 14
+        }
+      })).toBe(d`
+        four.four \\
+            .two.two \\
+            .two.two
+      `);
+    });
+    it("bracket breaks", () => {
+      expect(toSourceText([_$createComponent(py.MemberExpression, {
+        get children() {
+          return [_$createComponent(py.MemberExpression.Part, {
+            id: "obj"
+          }), _$createComponent(py.MemberExpression.Part, {
+            key: "property-name"
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "prop"
+          })];
+        }
+      })], {
+        printOptions: {
+          printWidth: 12
+        }
+      })).toBe(d`
+        obj[
+            "property-name"
+        ].prop
+      `);
+    });
+  });
+  describe("call chains", () => {
+    it("renders multiple calls on the same line when there are no breaks and they fit", () => {
+      expect(toSourceText([_$createComponent(py.MemberExpression, {
+        get children() {
+          return [_$createComponent(py.MemberExpression.Part, {
+            id: "z"
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "object"
+          }), _$createComponent(py.MemberExpression.Part, {
+            args: true
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "partial"
+          }), _$createComponent(py.MemberExpression.Part, {
+            args: true
+          }), _$createComponent(py.MemberExpression.Part, {
+            id: "optional"
+          }), _$createComponent(py.MemberExpression.Part, {
+            args: true
+          })];
+        }
+      })])).toBe(d`
+        z.object().partial().optional()
+      `);
+    });
+  });
+});