ng_form_model_test.dart

import'package:test/test.dart';
import'package:angular/angular.dart';
import'package:angular_forms/angular_forms.dart';
import'package:angular_test/angular_test.dart';

import'ng_form_model_test.template.dart'as ng;

MatcherthrowsWith(String s) =>
throwsA(predicate((e) => e.toString().contains(s)));

voidmain() {
 ng.initReflector();

group('NgFormModel', () {
lateNgTestFixture<NgFormModelTest> fixture;

tearDown(() =>disposeAnyRunningTest());

setUp(() async {
var testBed =NgTestBed(ng.createNgFormModelTestFactory());
 fixture =await testBed.create();
 });

test('should reexport control properties', () {
 fixture.update((cmp) {
final form = cmp.form!;
final formModel = cmp.formModel;
expect(form.control, formModel);
expect(form.value, formModel.value);
expect(form.valid, formModel.valid);
expect(form.errors, formModel.errors);
expect(form.pristine, formModel.pristine);
expect(form.dirty, formModel.dirty);
expect(form.touched, formModel.touched);
expect(form.untouched, formModel.untouched);
 });
 });

group('addControl', () {
test('should throw when no value accessor', () async {
await fixture.update((cmp) {
var dir =NgControlName(cmp.form!, null, null);
 dir.name ='login';
expect(() => cmp.form!.addControl(dir),
throwsWith('No value accessor for (login)'));
 });
 });

test('should set up validators', () async {
await fixture.update((cmp) {
// sync validators are set
expect(cmp.formModel.hasError('required', ['login']), true);
 (cmp.formModel.findPath(['login']) asControl)
 .updateValue('invalid value');
 });
 });

test('should write value to the DOM', () async {
await fixture.update((cmp) {
 (cmp.formModel.findPath(['login']) asControl)
 .updateValue('initValue');
expect(
 (cmp.loginControlDir!.valueAccessor asDummyControlValueAccessor)
 .writtenValue,
'initValue');
 });
 });

test(
'should add the directive to the list of directives '
'included in the form', () async {
await fixture.update((cmp) {
expect(cmp.form!.directives, [cmp.loginControlDir]);
 });
 });
 });

group('addControlGroup', () {
test('should set up validator', () async {
await fixture.update((cmp) {
 (cmp.formModel.findPath(['passwords', 'password']) asControl)
 .updateValue('somePassword');
 (cmp.formModel.findPath(['passwords', 'passwordConfirm']) asControl)
 .updateValue('someOtherPassword');
 });

await fixture.update((cmp) {
// sync validators are set
expect(cmp.formModel.hasError('differentPasswords', ['passwords']),
true);

 (cmp.formModel.findPath(['passwords', 'passwordConfirm']) asControl)
 .updateValue('somePassword');

expect(cmp.formModel.hasError('differentPasswords', ['passwords']),
false);
 });
 });
 });

group('removeControl', () {
test(
'should remove the directive to the list of directives included in '
'the form', () async {
await fixture.update((cmp) {
 cmp.needsLogin =false;
 });

await fixture.update((cmp) {
expect(cmp.form!.directives, []);
 });
 });
 });

group('ngAfterChanges', () {
test('should update dom values of all the directives', () async {
await fixture.update((cmp) {
 (cmp.formModel.findPath(['login']) asControl)
 .updateValue('new value');
 });
await fixture.update((cmp) {
expect(
 (cmp.loginControlDir!.valueAccessor asDummyControlValueAccessor)
 .writtenValue,
'new value');
 });
 });
 });
 });
}

@Component(
 selector:'ng-form-model-test',
 directives: [
 formDirectives,
DummyControlValueAccessor,
MatchingPasswordsValidator,
NgIf,
 ],
 template:'''
<div [ngFormModel]="formModel" #form="ngForm">
 <div *ngIf="needsLogin">
 <input [ngControl]="'login'" #login="ngForm" required dummy />
 </div>
 <div [ngControlGroup]="'passwords'" #passwords="ngForm" matchingPasswords>
 </div>
</div>
''',
)
classNgFormModelTest {
@ViewChild('form')
NgFormModel? form;

@ViewChild('login')
NgControlName? loginControlDir;

@ViewChild('passwords')
NgControlGroup? passwords;

bool needsLogin =true;

var formModel =ControlGroup({
'login':Control(),
'passwords':
ControlGroup({'password':Control(), 'passwordConfirm':Control()})
 });
}

@Directive(selector:'[dummy]', providers: [
ExistingProvider.forToken(
 ngValueAccessor,
DummyControlValueAccessor,
 )
])
classDummyControlValueAccessorimplementsControlValueAccessor<dynamic> {
dynamic writtenValue;

@override
voidwriteValue(dynamic obj) {
 writtenValue = obj;
 }

@override
voidregisterOnChange(fn) {}
@override
voidregisterOnTouched(fn) {}
@override
voidonDisabledChanged(bool isDisabled) {}
}

@Directive(selector:'[matchingPasswords]', providers: [
ValueProvider.forToken(
NG_VALIDATORS, MatchingPasswordsValidator.matchingPasswordsValidator),
])
classMatchingPasswordsValidator {
staticMap<String, dynamic>?matchingPasswordsValidator(
AbstractControl control) {
if (control is!ControlGroup) throwStateError('Must be ControlGroup');
var group = control;
if (group.controls['password']!.value !=
 group.controls['passwordConfirm']!.value) {
return {'differentPasswords':true};
 } else {
returnnull;
 }
 }
}