@spinnaker/azure 2026.2.2 → 2026.3.0

package/src/securityGroup/details/AzureSecurityGroupDetails.spec.tsx

@@ -0,0 +1,291 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+import { MenuItem } from 'react-bootstrap';
+
+import { AccountTag, CollapsibleSection, ConfirmationModalService } from '@spinnaker/core';
+
+import { AzureSecurityGroupModal } from '../configure/AzureSecurityGroupModal';
+import { AzureSecurityGroupWriter } from '../securityGroup.write.service';
+import {
+  AzureSecurityGroupActions,
+  AzureSecurityGroupDetailsComponent as AzureSecurityGroupDetails,
+  AzureSecurityGroupInformationSection,
+  AzureSecurityGroupRulesSection,
+} from './AzureSecurityGroupDetails';
+
+describe('AzureSecurityGroupDetails', () => {
+  const resolvedSecurityGroup = {
+    accountId: 'test-account',
+    name: 'fnord-sg',
+    provider: 'azure',
+    region: 'westus',
+    vpcId: 'vnet-1',
+  } as any;
+
+  function app() {
+    return {
+      name: 'fnord',
+      getDataSource: () => ({ ready: () => Promise.resolve(), onRefresh: () => jasmine.createSpy('unsubscribe') }),
+      securityGroups: { refresh: jasmine.createSpy('refresh') },
+    } as any;
+  }
+
+  function securityGroup() {
+    return {
+      account: 'test-account',
+      accountId: 'test-account',
+      name: 'fnord-sg',
+      region: 'westus',
+      securityRules: [
+        {
+          name: 'allow-web',
+          access: 'Allow',
+          destinationAddressPrefix: '*',
+          direction: 'Inbound',
+          priority: 100,
+          protocol: 'Tcp',
+          sourceAddressPrefixes: ['10.0.0.0/24', '192.168.0.0/24'],
+          sourcePortRange: '*',
+          destinationPortRanges: ['80', '443'],
+        },
+      ],
+      vpcId: 'vnet-1',
+    } as any;
+  }
+
+  it('closes missing details through the injected state service', () => {
+    const stateService = { go: jasmine.createSpy('go') };
+    const component = new AzureSecurityGroupDetails({
+      app: app(),
+      resolvedSecurityGroup,
+      router: {},
+      stateParams: {},
+      stateService,
+    } as any);
+
+    (component as any).autoClose();
+
+    expect(stateService.go).toHaveBeenCalledWith('^');
+  });
+
+  it('loads details with the core security group reader and renders basic sections', async () => {
+    const securityGroupReader = {
+      getSecurityGroupDetails: jasmine
+        .createSpy('getSecurityGroupDetails')
+        .and.returnValue(Promise.resolve(securityGroup())),
+    };
+    const wrapper = shallow(
+      <AzureSecurityGroupDetails
+        app={app()}
+        resolvedSecurityGroup={resolvedSecurityGroup}
+        securityGroupReader={securityGroupReader as any}
+      />,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+    wrapper.update();
+
+    expect(securityGroupReader.getSecurityGroupDetails).toHaveBeenCalledWith(
+      jasmine.anything(),
+      'test-account',
+      'azure',
+      'westus',
+      'vnet-1',
+      'fnord-sg',
+    );
+    expect(wrapper.find('h3').text()).toContain('fnord-sg');
+    expect(wrapper.find(AzureSecurityGroupActions).prop('securityGroup')).toEqual(securityGroup());
+    expect(wrapper.find(AzureSecurityGroupRulesSection).prop('securityGroup')).toEqual(securityGroup());
+  });
+
+  it('renders Azure security rules with normalized port and source values', () => {
+    const wrapper = shallow(<AzureSecurityGroupRulesSection securityGroup={securityGroup()} />);
+    const sectionContent = shallow(<div>{wrapper.find(CollapsibleSection).prop('children')}</div>);
+    const text = sectionContent.text();
+
+    expect(text).toContain('allow-web');
+    expect(text).toContain('100');
+    expect(text).toContain('10.0.0.0/24, 192.168.0.0/24');
+    expect(text).toContain('*');
+    expect(text).toContain('80, 443');
+    expect(text).toContain('Inbound');
+  });
+
+  it('renders legacy information fields from the Azure details panel', () => {
+    const wrapper = shallow(
+      <AzureSecurityGroupInformationSection
+        securityGroup={
+          {
+            accountName: 'prod-account',
+            description: 'frontend ingress',
+            id: 'nsg-resource-id',
+            region: 'westus',
+            vpcId: 'vnet-1',
+          } as any
+        }
+      />,
+    );
+    const sectionContent = shallow(<div>{wrapper.find(CollapsibleSection).prop('children')}</div>);
+    const text = sectionContent.text();
+
+    expect(text).toContain('nsg-resource-id');
+    expect(sectionContent.find(AccountTag).prop('account')).toBe('prod-account');
+    expect(text).toContain('westus');
+    expect(text).toContain('frontend ingress');
+  });
+
+  it('renders legacy details model fields for security rule source and ports', () => {
+    const wrapper = shallow(
+      <AzureSecurityGroupRulesSection
+        securityGroup={
+          {
+            securityRules: [
+              {
+                name: 'allow-web',
+                destinationPortRangeModel: '8080, 8443',
+                sourceAddressPrefixModel: '10.0.0.0/24, 192.168.0.0/24',
+              },
+            ],
+          } as any
+        }
+      />,
+    );
+    const sectionContent = shallow(<div>{wrapper.find(CollapsibleSection).prop('children')}</div>);
+    const text = sectionContent.text();
+
+    expect(text).toContain('10.0.0.0/24, 192.168.0.0/24');
+    expect(text).toContain('8080, 8443');
+  });
+
+  it('renders Azure security rules sorted by priority', () => {
+    const wrapper = shallow(
+      <AzureSecurityGroupRulesSection
+        securityGroup={
+          {
+            securityRules: [
+              { name: 'second', priority: 200, destinationPortRange: '443', sourceAddressPrefix: '*' },
+              { name: 'first', priority: 100, destinationPortRange: '80', sourceAddressPrefix: '*' },
+            ],
+          } as any
+        }
+      />,
+    );
+    const sectionContent = shallow(<div>{wrapper.find(CollapsibleSection).prop('children')}</div>);
+    const ruleNames = sectionContent.find('tbody tr').map((row) => row.find('td').at(1).text());
+
+    expect(ruleNames).toEqual(['first', 'second']);
+  });
+
+  it('reloads when coordinates change and ignores stale responses', async () => {
+    let resolveFirst: (value: any) => void;
+    let resolveSecond: (value: any) => void;
+    const securityGroupReader = {
+      getSecurityGroupDetails: jasmine
+        .createSpy('getSecurityGroupDetails')
+        .and.callFake(
+          (_app: any, _account: string, _provider: string, _region: string, _vpcId: string, name: string) => {
+            if (name === 'fnord-sg') {
+              return new Promise((resolve) => {
+                resolveFirst = resolve;
+              });
+            }
+            return new Promise((resolve) => {
+              resolveSecond = resolve;
+            });
+          },
+        ),
+    };
+    const wrapper = shallow(
+      <AzureSecurityGroupDetails
+        app={app()}
+        resolvedSecurityGroup={resolvedSecurityGroup}
+        securityGroupReader={securityGroupReader as any}
+      />,
+    );
+
+    await Promise.resolve();
+    wrapper.setProps({ resolvedSecurityGroup: { ...resolvedSecurityGroup, name: 'other-sg' } });
+    await Promise.resolve();
+    resolveSecond({ ...securityGroup(), name: 'other-sg' });
+    await Promise.resolve();
+    resolveFirst(securityGroup());
+    await Promise.resolve();
+    wrapper.update();
+
+    expect(securityGroupReader.getSecurityGroupDetails.calls.count()).toBe(2);
+    expect(wrapper.find('h3').text()).toContain('other-sg');
+  });
+
+  it('auto-closes when the details response is empty', async () => {
+    const autoClose = jasmine.createSpy('autoClose');
+    const securityGroupReader = {
+      getSecurityGroupDetails: jasmine.createSpy('getSecurityGroupDetails').and.returnValue(Promise.resolve({})),
+    };
+
+    shallow(
+      <AzureSecurityGroupDetails
+        app={app()}
+        autoClose={autoClose}
+        resolvedSecurityGroup={resolvedSecurityGroup}
+        securityGroupReader={securityGroupReader as any}
+      />,
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(autoClose).toHaveBeenCalled();
+  });
+
+  it('opens edit, clone, and delete actions', () => {
+    spyOn(AzureSecurityGroupModal, 'show');
+    spyOn(ConfirmationModalService, 'confirm');
+    spyOn(AzureSecurityGroupWriter, 'deleteSecurityGroup').and.returnValue(Promise.resolve({} as any));
+    const wrapper = shallow(<AzureSecurityGroupActions app={app()} securityGroup={securityGroup()} />);
+
+    wrapper.find(MenuItem).at(0).prop('onClick')({} as any);
+    wrapper.find(MenuItem).at(1).prop('onClick')({} as any);
+    wrapper.find(MenuItem).at(2).prop('onClick')({} as any);
+
+    expect(AzureSecurityGroupModal.show).toHaveBeenCalledWith(jasmine.objectContaining({ mode: 'edit' }));
+    expect(AzureSecurityGroupModal.show).toHaveBeenCalledWith(jasmine.objectContaining({ mode: 'clone' }));
+    expect(ConfirmationModalService.confirm).toHaveBeenCalled();
+    const confirmArgs = (ConfirmationModalService.confirm as jasmine.Spy).calls.mostRecent().args[0];
+    confirmArgs.submitMethod();
+    expect(AzureSecurityGroupWriter.deleteSecurityGroup).toHaveBeenCalledWith(
+      securityGroup(),
+      jasmine.anything(),
+      jasmine.objectContaining({ cloudProvider: 'azure', vpcId: 'vnet-1' }),
+    );
+  });
+
+  it('uses resolved coordinates when deleting fetched details without account identity', () => {
+    spyOn(ConfirmationModalService, 'confirm');
+    spyOn(AzureSecurityGroupWriter, 'deleteSecurityGroup').and.returnValue(Promise.resolve({} as any));
+    const fetchedDetails = {
+      name: 'fnord-sg',
+      region: 'westus',
+      securityRules: [],
+      vpcId: 'vnet-1',
+    } as any;
+    const wrapper = shallow(
+      React.createElement(AzureSecurityGroupActions as any, {
+        app: app(),
+        resolvedSecurityGroup,
+        securityGroup: fetchedDetails,
+      }),
+    );
+
+    wrapper.find(MenuItem).at(2).prop('onClick')({} as any);
+
+    const confirmArgs = (ConfirmationModalService.confirm as jasmine.Spy).calls.mostRecent().args[0];
+    expect(confirmArgs.account).toBe('test-account');
+    confirmArgs.submitMethod();
+    expect(AzureSecurityGroupWriter.deleteSecurityGroup).toHaveBeenCalledWith(
+      jasmine.objectContaining({ accountId: 'test-account', name: 'fnord-sg', region: 'westus' }),
+      jasmine.anything(),
+      jasmine.objectContaining({ cloudProvider: 'azure', vpcId: 'vnet-1' }),
+    );
+  });
+});

package/src/securityGroup/details/AzureSecurityGroupDetails.tsx

@@ -0,0 +1,354 @@
+import React from 'react';
+import { Dropdown, MenuItem } from 'react-bootstrap';
+
+import type {
+  Application,
+  IOverridableProps,
+  IRouterInjectedProps,
+  ISecurityGroupDetail,
+  SecurityGroupReader,
+} from '@spinnaker/core';
+import {
+  AccountTag,
+  CollapsibleSection,
+  ConfirmationModalService,
+  DeckRuntimeContext,
+  withRouter,
+} from '@spinnaker/core';
+
+import { AzureSecurityGroupModal } from '../configure/AzureSecurityGroupModal';
+import { AzureSecurityGroupWriter } from '../securityGroup.write.service';
+
+interface IAzureResolvedSecurityGroup {
+  accountId?: string;
+  name: string;
+  provider?: string;
+  region: string;
+  vpcId?: string;
+}
+
+interface IAzureSecurityGroupDetailsProps extends IOverridableProps {
+  app: Application;
+  autoClose?: () => void;
+  resolvedSecurityGroup: IAzureResolvedSecurityGroup;
+  securityGroupReader?: SecurityGroupReader;
+}
+
+interface IAzureSecurityGroupDetailsState {
+  loading: boolean;
+  securityGroup?: ISecurityGroupDetail & Record<string, any>;
+}
+
+interface IAzureSecurityGroupSectionProps {
+  securityGroup: ISecurityGroupDetail & Record<string, any>;
+}
+
+export class AzureSecurityGroupDetailsComponent extends React.Component<
+  IAzureSecurityGroupDetailsProps & IRouterInjectedProps,
+  IAzureSecurityGroupDetailsState
+> {
+  public static contextType = DeckRuntimeContext;
+  public declare context: React.ContextType<typeof DeckRuntimeContext>;
+
+  public state: IAzureSecurityGroupDetailsState = { loading: true };
+
+  private isUnmounted = false;
+  private loadRequestId = 0;
+  private unsubscribeFromRefresh: () => void;
+
+  public componentDidMount(): void {
+    const dataSource = this.props.app.getDataSource?.('securityGroups');
+    if (!dataSource) {
+      this.loadSecurityGroup();
+      return;
+    }
+
+    dataSource.ready().then(() => {
+      if (this.isUnmounted) {
+        return;
+      }
+      this.loadSecurityGroup();
+      this.unsubscribeFromRefresh = dataSource.onRefresh(this.loadSecurityGroup);
+    });
+  }
+
+  public componentWillUnmount(): void {
+    this.isUnmounted = true;
+    if (this.unsubscribeFromRefresh) {
+      this.unsubscribeFromRefresh();
+    }
+  }
+
+  public componentDidUpdate(prevProps: IAzureSecurityGroupDetailsProps): void {
+    if (this.getCoordinatesKey(prevProps) !== this.getCoordinatesKey(this.props)) {
+      this.loadSecurityGroup();
+    }
+  }
+
+  private getCoordinatesKey(props: IAzureSecurityGroupDetailsProps): string {
+    const { accountId, name, region, vpcId } = props.resolvedSecurityGroup;
+    return [accountId, region, vpcId || '', name].join(':');
+  }
+
+  private getSecurityGroupReader(): SecurityGroupReader {
+    return this.props.securityGroupReader || this.context.services.securityGroupReader;
+  }
+
+  private loadSecurityGroup = (): void => {
+    const { app, resolvedSecurityGroup } = this.props;
+    const requestId = ++this.loadRequestId;
+    this.setState({ loading: true });
+    this.getSecurityGroupReader()
+      .getSecurityGroupDetails(
+        app,
+        resolvedSecurityGroup.accountId,
+        'azure',
+        resolvedSecurityGroup.region,
+        resolvedSecurityGroup.vpcId || '',
+        resolvedSecurityGroup.name,
+      )
+      .then((securityGroup: ISecurityGroupDetail & Record<string, any>) => {
+        if (this.isUnmounted || requestId !== this.loadRequestId) {
+          return;
+        }
+        if (!securityGroup || Object.keys(securityGroup).length === 0) {
+          this.autoClose();
+          return;
+        }
+        this.setState({ loading: false, securityGroup });
+      })
+      .catch(() => {
+        if (requestId === this.loadRequestId) {
+          this.autoClose();
+        }
+      });
+  };
+
+  private autoClose = (): void => {
+    if (this.isUnmounted) {
+      return;
+    }
+    if (this.props.autoClose) {
+      this.props.autoClose();
+      return;
+    }
+    this.props.stateService.go('^');
+  };
+
+  private closeDetails = (): void => {
+    this.props.stateService.go('^');
+  };
+
+  public render(): JSX.Element {
+    const { app } = this.props;
+    const { loading, securityGroup } = this.state;
+
+    if (loading || !securityGroup) {
+      return (
+        <div className="details-panel">
+          <div className="header">
+            <div className="close-button">
+              <a className="btn btn-link" onClick={this.closeDetails}>
+                <span className="glyphicon glyphicon-remove" />
+              </a>
+            </div>
+            <h4 className="text-center">Loading...</h4>
+          </div>
+        </div>
+      );
+    }
+
+    return (
+      <div className="details-panel">
+        <div className="header">
+          <div className="close-button">
+            <a className="btn btn-link" onClick={this.closeDetails}>
+              <span className="glyphicon glyphicon-remove" />
+            </a>
+          </div>
+          <div className="header-text horizontal middle">
+            <h3>{securityGroup.name}</h3>
+          </div>
+          <div className="actions">
+            <AzureSecurityGroupActions
+              app={app}
+              resolvedSecurityGroup={this.props.resolvedSecurityGroup}
+              securityGroup={securityGroup}
+            />
+          </div>
+        </div>
+        <div className="content">
+          <AzureSecurityGroupInformationSection securityGroup={securityGroup} />
+          <AzureSecurityGroupRulesSection securityGroup={securityGroup} />
+        </div>
+      </div>
+    );
+  }
+}
+
+export const AzureSecurityGroupDetails = withRouter(AzureSecurityGroupDetailsComponent);
+
+function withResolvedCoordinates(securityGroup: any, resolvedSecurityGroup?: IAzureResolvedSecurityGroup): any {
+  if (!resolvedSecurityGroup) {
+    return securityGroup;
+  }
+
+  const accountId =
+    securityGroup.accountId ||
+    securityGroup.account ||
+    securityGroup.accountName ||
+    securityGroup.credentials ||
+    resolvedSecurityGroup.accountId;
+  const name = securityGroup.name || resolvedSecurityGroup.name;
+  const region = securityGroup.region || resolvedSecurityGroup.region;
+  const vpcId = securityGroup.vpcId || resolvedSecurityGroup.vpcId;
+
+  if (
+    accountId === securityGroup.accountId &&
+    name === securityGroup.name &&
+    region === securityGroup.region &&
+    vpcId === securityGroup.vpcId
+  ) {
+    return securityGroup;
+  }
+
+  return { ...securityGroup, accountId, name, region, vpcId };
+}
+
+export function AzureSecurityGroupActions({
+  app,
+  resolvedSecurityGroup,
+  securityGroup,
+}: {
+  app: Application;
+  resolvedSecurityGroup?: IAzureResolvedSecurityGroup;
+  securityGroup: any;
+}) {
+  const securityGroupWithCoordinates = withResolvedCoordinates(securityGroup, resolvedSecurityGroup);
+  const editSecurityGroup = (): void => {
+    AzureSecurityGroupModal.show({ app, mode: 'edit', securityGroup: securityGroupWithCoordinates });
+  };
+  const cloneSecurityGroup = (): void => {
+    AzureSecurityGroupModal.show({ app, mode: 'clone', securityGroup: securityGroupWithCoordinates });
+  };
+  const deleteSecurityGroup = (): void => {
+    ConfirmationModalService.confirm({
+      header: `Really delete ${securityGroupWithCoordinates.name}?`,
+      buttonText: `Delete ${securityGroupWithCoordinates.name}`,
+      account: securityGroupWithCoordinates.accountId || securityGroupWithCoordinates.account,
+      taskMonitorConfig: {
+        application: app,
+        title: `Deleting ${securityGroupWithCoordinates.name}`,
+      },
+      submitMethod: () =>
+        AzureSecurityGroupWriter.deleteSecurityGroup(securityGroupWithCoordinates, app, {
+          cloudProvider: 'azure',
+          vpcId: securityGroupWithCoordinates.vpcId,
+        }),
+    });
+  };
+
+  return (
+    <Dropdown className="dropdown" id="azure-security-group-actions-dropdown">
+      <Dropdown.Toggle className="btn btn-sm btn-primary dropdown-toggle">Security Group Actions</Dropdown.Toggle>
+      <Dropdown.Menu>
+        <MenuItem onClick={editSecurityGroup}>Edit Inbound Rules</MenuItem>
+        <MenuItem onClick={cloneSecurityGroup}>Clone Security Group</MenuItem>
+        <MenuItem onClick={deleteSecurityGroup}>Delete Security Group</MenuItem>
+      </Dropdown.Menu>
+    </Dropdown>
+  );
+}
+
+export function AzureSecurityGroupInformationSection({ securityGroup }: IAzureSecurityGroupSectionProps) {
+  return (
+    <CollapsibleSection heading="Information" defaultExpanded={true}>
+      <dl className="dl-horizontal dl-narrow">
+        <dt>ID</dt>
+        <dd>{securityGroup.id || '-'}</dd>
+        <dt>Account</dt>
+        <dd>
+          <AccountTag account={securityGroup.accountId || securityGroup.accountName || securityGroup.account} />
+        </dd>
+        <dt>Region</dt>
+        <dd>{securityGroup.region}</dd>
+        <dt>Description:</dt>
+        <dd>{securityGroup.description || '-'}</dd>
+        <dt>VNet</dt>
+        <dd>{securityGroup.vpcId || '-'}</dd>
+      </dl>
+    </CollapsibleSection>
+  );
+}
+
+function joinRuleValues(...values: any[]): string {
+  for (const value of values) {
+    if (Array.isArray(value) && value.length) {
+      return value.join(', ');
+    }
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+  return '-';
+}
+
+function ruleSources(rule: any): string {
+  return joinRuleValues(
+    rule.sourceAddressPrefixModel,
+    rule.sourceAddressPrefixes,
+    rule.sourceAddressPrefix,
+    rule.sourceIPCIDRRanges,
+    rule.sourceCidrs,
+  );
+}
+
+function rulePorts(rule: any): string {
+  return joinRuleValues(
+    rule.destinationPortRangeModel,
+    rule.destinationPortRanges,
+    rule.destinationPortRange,
+    rule.destPortRanges,
+    rule.destinationPorts,
+  );
+}
+
+export function AzureSecurityGroupRulesSection({ securityGroup }: IAzureSecurityGroupSectionProps) {
+  const rules = (securityGroup.securityRules || securityGroup.inboundRules || [])
+    .slice()
+    .sort((a: any, b: any) => (a.priority ?? Number.MAX_SAFE_INTEGER) - (b.priority ?? Number.MAX_SAFE_INTEGER));
+  return (
+    <CollapsibleSection heading="Inbound Rules" defaultExpanded={true}>
+      <table className="table table-condensed">
+        <thead>
+          <tr>
+            <th>Priority</th>
+            <th>Name</th>
+            <th>Source</th>
+            <th>Source Port</th>
+            <th>Destination</th>
+            <th>Ports</th>
+            <th>Protocol</th>
+            <th>Access</th>
+            <th>Direction</th>
+          </tr>
+        </thead>
+        <tbody>
+          {rules.map((rule: any, index: number) => (
+            <tr key={rule.name || index}>
+              <td>{rule.priority || '-'}</td>
+              <td>{rule.name || '-'}</td>
+              <td>{ruleSources(rule)}</td>
+              <td>{rule.sourcePortRange || '-'}</td>
+              <td>{rule.destinationAddressPrefix || '-'}</td>
+              <td>{rulePorts(rule)}</td>
+              <td>{rule.protocol || '-'}</td>
+              <td>{rule.access || '-'}</td>
+              <td>{rule.direction || '-'}</td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </CollapsibleSection>
+  );
+}

package/src/securityGroup/securityGroup.reader.js

@@ -1,17 +1,7 @@
-'use strict';
-
-import { module } from 'angular';
-
-export const AZURE_SECURITYGROUP_SECURITYGROUP_READER = 'spinnaker.azure.securityGroup.reader';
-export const name = AZURE_SECURITYGROUP_SECURITYGROUP_READER; // for backwards compatibility
-module(AZURE_SECURITYGROUP_SECURITYGROUP_READER, []).factory('azureSecurityGroupReader', function () {
-  function resolveIndexedSecurityGroup(indexedSecurityGroups, container, securityGroupId) {
+export class AzureSecurityGroupReader {
+  resolveIndexedSecurityGroup(indexedSecurityGroups, container, securityGroupId) {
     //hack to get around securityGroupId not matching id in indexedSecurityGroups.
     const temp = securityGroupId.split('/');
     return indexedSecurityGroups[container.account][container.region][temp[temp.length - 1]];
   }
-
-  return {
-    resolveIndexedSecurityGroup: resolveIndexedSecurityGroup,
-  };
-});
+}

package/src/securityGroup/securityGroup.transformer.js

@@ -1,13 +1,3 @@
-'use strict';
-
-import { module } from 'angular';
-
-export const AZURE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER = 'spinnaker.azure.securityGroup.transformer';
-export const name = AZURE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER; // for backwards compatibility
-module(AZURE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER, []).factory('azureSecurityGroupTransformer', function () {
-  function normalizeSecurityGroup() {}
-
-  return {
-    normalizeSecurityGroup: normalizeSecurityGroup,
-  };
-});
+export class AzureSecurityGroupTransformer {
+  normalizeSecurityGroup() {}
+}