fixed persistence flag bug in relation metadata, more tests for #1319

src/metadata/RelationMetadata.ts

@@ -265,7 +265,7 @@ export class RelationMetadata {
         this.onDelete = args.options.onDelete;
         this.isPrimary = args.options.primary || false;
         this.isEager = args.options.eager || false;
-        this.persistenceEnabled = args.options.persistence || true;
+        this.persistenceEnabled = args.options.persistence === false ? false : true;
         this.isTreeParent = args.isTreeParent || false;
         this.isTreeChildren = args.isTreeChildren || false;
         this.type = args.type instanceof Function ? (args.type as () => any)() : args.type;

test/functional/entity-metadata-validator/initialized-relations/entity/Image.ts

@@ -0,0 +1,19 @@
+import {Entity} from "../../../../../src/decorator/entity/Entity";
+import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
+import {Column} from "../../../../../src/decorator/columns/Column";
+import {ImageInfo} from "./ImageInfo";
+import {OneToMany} from "../../../../../src/decorator/relations/OneToMany";
+
+@Entity()
+export class Image {
+
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @Column()
+    title: string;
+
+    @OneToMany(type => ImageInfo, imageInfo => imageInfo.image)
+    informations: ImageInfo[] = [];
+
+}

test/functional/entity-metadata-validator/initialized-relations/entity/ImageInfo.ts

@@ -0,0 +1,19 @@
+import {Entity} from "../../../../../src/decorator/entity/Entity";
+import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
+import {Column} from "../../../../../src/decorator/columns/Column";
+import {ManyToOne} from "../../../../../src/decorator/relations/ManyToOne";
+import {Image} from "./Image";
+
+@Entity()
+export class ImageInfo {
+
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @Column()
+    name: string;
+
+    @ManyToOne(type => Image, image => image.informations)
+    image: Image;
+
+}

test/functional/entity-metadata-validator/initialized-relations/entity/Question.ts

@@ -0,0 +1,21 @@
+import {Entity} from "../../../../../src/decorator/entity/Entity";
+import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
+import {Column} from "../../../../../src/decorator/columns/Column";
+import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
+import {Category} from "./Category";
+import {JoinTable} from "../../../../../src/decorator/relations/JoinTable";
+
+@Entity()
+export class Question {
+
+    @PrimaryGeneratedColumn()
+    id: number;
+
+    @Column()
+    title: string;
+
+    @ManyToMany(type => Category, { persistence: false })
+    @JoinTable()
+    categories: Category[] = [];
+
+}

test/functional/entity-metadata-validator/initialized-relations/validator-intialized-relations.ts

@@ -6,10 +6,13 @@ import {expect} from "chai";
 import {InitializedRelationError} from "../../../../src/error/InitializedRelationError";
 import {Category} from "./entity/Category";
 import {Post} from "./entity/Post";
+import {Image} from "./entity/Image";
+import {ImageInfo} from "./entity/ImageInfo";
+import {Question} from "./entity/Question";
 
-describe.only("entity-metadata-validator > initialized relations", () => {
+describe("entity-metadata-validator > initialized relations", () => {
 
-    it("should throw error if relation with initialized array was found", () => {
+    it("should throw error if relation with initialized array was found on many-to-many relation", () => {
         const connection = new Connection({ // dummy connection options, connection won't be established anyway
             type: "mysql",
             host: "localhost",
@@ -24,4 +27,49 @@ describe.only("entity-metadata-validator > initialized relations", () => {
         expect(() => entityMetadataValidator.validateMany(entityMetadatas, connection.driver)).to.throw(InitializedRelationError);
     });
 
+    it("should throw error if relation with initialized array was found on one-to-many relation", () => {
+        const connection = new Connection({ // dummy connection options, connection won't be established anyway
+            type: "mysql",
+            host: "localhost",
+            username: "test",
+            password: "test",
+            database: "test",
+            entities: [Image, ImageInfo]
+        });
+        const connectionMetadataBuilder = new ConnectionMetadataBuilder(connection);
+        const entityMetadatas = connectionMetadataBuilder.buildEntityMetadatas([Image, ImageInfo], []);
+        const entityMetadataValidator = new EntityMetadataValidator();
+        expect(() => entityMetadataValidator.validateMany(entityMetadatas, connection.driver)).to.throw(InitializedRelationError);
+    });
+
+    it("should not throw error if relation with initialized array was not found", () => {
+        const connection = new Connection({ // dummy connection options, connection won't be established anyway
+            type: "mysql",
+            host: "localhost",
+            username: "test",
+            password: "test",
+            database: "test",
+            entities: [Category]
+        });
+        const connectionMetadataBuilder = new ConnectionMetadataBuilder(connection);
+        const entityMetadatas = connectionMetadataBuilder.buildEntityMetadatas([Category], []);
+        const entityMetadataValidator = new EntityMetadataValidator();
+        expect(() => entityMetadataValidator.validateMany(entityMetadatas, connection.driver)).not.to.throw(InitializedRelationError);
+    });
+
+    it("should not throw error if relation with initialized array was found, but persistence for this relation was disabled", () => {
+        const connection = new Connection({ // dummy connection options, connection won't be established anyway
+            type: "mysql",
+            host: "localhost",
+            username: "test",
+            password: "test",
+            database: "test",
+            entities: [Question, Category]
+        });
+        const connectionMetadataBuilder = new ConnectionMetadataBuilder(connection);
+        const entityMetadatas = connectionMetadataBuilder.buildEntityMetadatas([Question, Category], []);
+        const entityMetadataValidator = new EntityMetadataValidator();
+        expect(() => entityMetadataValidator.validateMany(entityMetadatas, connection.driver)).not.to.throw(InitializedRelationError);
+    });
+
 });